iOS 13: Notable UIKit Additions

June 07, 2019

Though UIKit wasn't the star of the show, its number of improvements certainly don't show it. Let's see what's new in iOS 13 for our favorite framework.

continue.reading(with: iOS 13: Notable UIKit Additions)

WWDC 2019: The Pregame Quiz

May 23, 2019

iOS 13 is coming. Before Marzipan and Dark Mode show their respective faces, let's enjoy another annual pregame quiz!

continue.reading(with: WWDC 2019: The Pregame Quiz)

NSSecureCoding

May 03, 2019

Any application on iOS is a purveyor of data in some capacity. NSSecureCoding ensures that this data is what it says it is, and will do what it says it should do.

continue.reading(with: NSSecureCoding)

I Made Some Pancakes

April 02, 2019

What can fluffy butter cakes teach me about indie development? Apparently, just what I needed to learn.

continue.reading(with: I Made Some Pancakes)

Handling iCloud Assets

March 27, 2019

Rich media plays an important role in the mobile ecosystem. Working with them when they're located off-site requires some nuance.

continue.reading(with: Handling iCloud Assets)

A Best in Class iOS App

February 25, 2019

What is a best in class iOS app? How are they built, and can we quantify what makes them great?

continue.reading(with: A Best in Class iOS App)

NS_CLOSED_ENUM

February 14, 2019

Enumerations provide clarity and intent. Some change and yet others remain stagnant, and now we program effectively for either case.

continue.reading(with: NS_CLOSED_ENUM)

The Chart That Lies

January 24, 2019

On being realistic about the things we make, and the relationship that time has with them.

continue.reading(with: The Chart That Lies)

Optimizing Images

December 11, 2018

iOS is a visual medium teeming with beautiful images in virtually every app on your phone. Important though they are, it's trivial to mismanage them from a memory and performance standpoint.

continue.reading(with: Optimizing Images)

Supporting External Displays

November 03, 2018

With the iPad Pro's USB-C support, the opportunity to support external displays in a first class manner has never been more pertinent. Doing so doesn't require much work, and the potential value add is high.

continue.reading(with: Supporting External Displays)

UIGraphicsImageRenderer

August 01, 2018

For years, we've used Core Graphics to draw. Let's turn the page to modern drawing on iOS.

continue.reading(with: UIGraphicsImageRenderer)

iOS 12: Notable UIKit Additions

June 08, 2018

Our favorite framework for user interface creations becomes faster and a bit more nimble with iOS 12.

continue.reading(with: iOS 12: Notable UIKit Additions)

WWDC 2018: The Pregame Quiz

May 30, 2018

iOS 12 beckons, but before it does - let's quiz it up over iOS versions of yesterday.

continue.reading(with: WWDC 2018: The Pregame Quiz)

NSPredicate

May 18, 2018

Twist and turn your way through collections and data sets with ease.

continue.reading(with: NSPredicate)

UILayoutGuide

April 15, 2018

Spacer views often make user interface creation more palatable, but with significant drawbacks. There's a more pragmatic way.

continue.reading(with: UILayoutGuide)

Connecting iOS Apps with Their Websites

February 03, 2018

As developers, marketing often escapes the lot of us. Fortnuately, Apple has made a few quick wins available to create meanginful connections between your app and its web site.

continue.reading(with: Connecting iOS Apps with Their Websites)

NSMeasurement

December 17, 2017

Measuring units can be a daunting task, especially with the global audience we often serve. Let's see how Foundation can lend a hand.

continue.reading(with: NSMeasurement)

Copy on Write

November 07, 2017

Yet again, Foundation dishes out free optimizations without us having to lift a finger. Let's see how collections became a bit smarter.

continue.reading(with: Copy on Write)

Device Check Overview

October 06, 2017

There are legitimate uses for tagging devices, but the problem is, doing so can down shady roads. Now, we've got a non shady way to go about it.

continue.reading(with: Device Check Overview)

Dealing with Home Indicator

September 13, 2017

View Controllers are notorious for the amount of responsibilities they have, but get ready for one more. Here's how to handle the home indicator.

continue.reading(with: Dealing with Home Indicator)

Random Wisdom: Part 1

August 10, 2017

In our first edition of random wisdom, let's poke around around some Objective-C. Inline blocks, how selectors work and more.

continue.reading(with: Random Wisdom: Part 1)

SFAuthenticationSession

July 14, 2017

Single sign on isn't gone, in fact - it's better. Enter a new way to deal with OAuth.

continue.reading(with: SFAuthenticationSession)

simctl

June 24, 2017

The iOS emulator is deceptively powerful. Learn about its C.L.I. to automate all sorts of things.

continue.reading(with: simctl)

iOS 11: Notable UIKit Additions

June 07, 2017

Once again, UIKit added more firepower. Beyond drag and drop APIs, there's much more to be excited about.

continue.reading(with: iOS 11: Notable UIKit Additions)

WWDC 2017: The Pregame Quiz

June 04, 2017

Time to fire up the trivia machine, WWDC 17 is around the corner. What better time to test your wit against some Apple history?

continue.reading(with: WWDC 2017: The Pregame Quiz)

Global Functions

May 15, 2017

UIKit has everything to splash out eye candy. But it also houses several helpful utilities to help get you there.

continue.reading(with: Global Functions)

Tail Call Elimination

April 21, 2017

Foundation keeps caches hot and saves on precious stack memory via tail call elimination. Let's take a look at how this occurs.

continue.reading(with: Tail Call Elimination)

Attributes in Swift

April 04, 2017

Attributes can keep code clean and conscise without much effort. Today, let's cover some common, and uncommon, use cases.

continue.reading(with: Attributes in Swift)

Swift Keywords

February 11, 2017

Swift has quite a few keywords. Let's look at every single one, what it does and provide a code sample.

continue.reading(with: Swift Keywords)

UIStackView: A Field Guide

January 15, 2017

Stack View has been pushed heavily by Apple, but sometimes its complexity overshadows its utility. A few simple tips can help ease that burden.

continue.reading(with: UIStackView: A Field Guide)

NS_SWIFT_NAME

December 23, 2016

Interop is required in the world we live in. Here's an attribute in Swift that can help make things easier.

continue.reading(with: NS_SWIFT_NAME)

noescape

November 25, 2016

It's an attribute you've seen hanging over closures. Let's dive into what it means, or more specifically - meant.

continue.reading(with: noescape)

iOS True Confessions

November 06, 2016

There is no developer who knows it all, and in our industry imposter syndrome runs rampant. So, let's break those walls and celebrate all that we don't know.

continue.reading(with: iOS True Confessions)

Consuming and Transforming Arrays

August 27, 2016

The Swift Stand Library offers up several differeny ways to work with arrays. From sorting to sifting, almost every use case is covered efficiently.

continue.reading(with: Consuming and Transforming Arrays)

Leveraging Swift Enums for Quick Actions

August 21, 2016

Quick Actions are a staple component of a first class 3D Touch experience. Implementing them using Swift's enumerations makes for a pragmatic approach.

continue.reading(with: Leveraging Swift Enums for Quick Actions)

Initialization with Closures

August 11, 2016

More than just an anonymous function, Swift's closures are extremely versatile. One such use case for them is initialization.

continue.reading(with: Initialization with Closures)

On Learning iOS

July 23, 2016

iOS, once a newly minted discipline, is now a large world. It's intimidating to get started, so here's my simple take on how to get going quickly.

continue.reading(with: On Learning iOS)

#keyPath

July 01, 2016

Selectors are a part of iOS development daily. They can also be a common source of frustrating bugs, but #keyPath is here to help.

continue.reading(with: #keyPath)

WWDC 2016: The Pregame Quiz

June 07, 2016

It's our favorite time of the year, dub dub. Let's kick it off with some Apple trivia.

continue.reading(with: WWDC 2016: The Pregame Quiz)

Swift 3 Feature Highlight

May 16, 2016

Our favorite open source language is changing at a rapid pace. Here, we'll check out some of my favorite additions that landed in Swift 3.

continue.reading(with: Swift 3 Feature Highlight)

Access Control

April 21, 2016

Abstraction is a tent pole component of modern programming. Swift's robust tooling for access control can help us enforce it.

continue.reading(with: Access Control)

A Swift Refactor

March 26, 2016

Swift offers us several novel ways to refactor our code. Follow along as we embark on such a task on some fictional code.

continue.reading(with: A Swift Refactor)

iOS Citizenship: Reacting to Low Power Mode

March 04, 2016

It's a term you've likely heard in the development community - being a good citizen. What does it mean, and how can we do just that?

continue.reading(with: iOS Citizenship: Reacting to Low Power Mode)

iOS Architecture Patterns: Part 3

February 20, 2016

Our third and final discussion on common iOS archiecture patterns, and perhaps the most important. Let's chat MVC.

continue.reading(with: iOS Architecture Patterns: Part 3)

iOS Architecture Patterns: Part 2

February 06, 2016

Our second discussion on iOS architecture patterns. Here's how delegation is imprinted across Cocoa Touch.

continue.reading(with: iOS Architecture Patterns: Part 2)

iOS Architecture Patterns: Part 1

January 22, 2016

Our first discussion over iOS architecture patterns. Let's peer into the world of target-action.

continue.reading(with: iOS Architecture Patterns: Part 1)

ARC

January 09, 2016

Automatic reference counting debuted several years ago and ushered in a new era of memory management. But, how does it work with Swift?

continue.reading(with: ARC)

Initialization

December 17, 2015

If you're coming from Objective-C or are new to Swift, the way its initialization works can be confusing. Diving into the particulars is a worthwhile effort.

continue.reading(with: Initialization)

Protocol Extensions

November 26, 2015

It's possible to enhance a wide family of objects with protocol extensions. Today we'll try and see how its possible.

continue.reading(with: Protocol Extensions)

Option Set

October 31, 2015

Option Sets solve a large swath of problems, but you may not think to use them at first. Looking at how they work and why their useful might change your mind.

continue.reading(with: Option Set)

Javascript

October 04, 2015

Javascript and...Swift? It works better than you might think, and for more than just parlor tricks.

continue.reading(with: Javascript)

Error Handling

September 11, 2015

Dealing with errors is usually a developer's favorite task to procrastinate against. But it shouldn't be, and even though Swift's inplementation is differnt - it's robust.

continue.reading(with: Error Handling)

Guard

August 21, 2015

More than an _if_ statement, this simple construct makes code safer and readable. But when do you use one or the other?

continue.reading(with: Guard)

Defer

July 18, 2015

More than an _if_ statement, this simple construct makes code safer and readable. But when do you use one or the other?

continue.reading(with: Defer)

Quality of Service

July 11, 2015

Threading, concurrency and parallelism can be a sticky subject. Thankfully, Foundation has an API to make everything safer.

continue.reading(with: Quality of Service)

Objective-C in 2015

July 04, 2015

Apple has decreed that it's Swift's world and Objective-C is just living in it. Paradoxically, it's almost made it better than it's ever been.

continue.reading(with: Objective-C in 2015)

Pattern Matching

June 20, 2015

Pattern matching with Swift yields concise code when it otherwise might be a bit more convoluted. Here's how it works.

continue.reading(with: Pattern Matching)

Protocol Oriented Programming

June 15, 2015

The infamous WWDC session introduced us to 'Protocol Oriented Programming'. Really, though - what is it?

continue.reading(with: Protocol Oriented Programming)

WWDC 2015: The Pregame Quiz

June 05, 2015

Now that WWDC is here, let's start a new annual tradition. It's time for the very first WWDC Pregame Quiz.

continue.reading(with: WWDC 2015: The Pregame Quiz)

Definitive Initialization

May 23, 2015

Swift goes to great lengths to ensure values are initialized before they are used. The reasons how vary from API design to the way LLVM works - let's chat about this process called definitive initialization.

continue.reading(with: Definitive Initialization)

Objective-C and Swift Together

May 16, 2015

We've now hit the inflection point where your Objective-C projects must mix with Swift, or vice-versa. Here's how my first experience with it went.

continue.reading(with: Objective-C and Swift Together)

bool

May 02, 2015

The boolean variable, perhaps the most simple implementation in Computer Science - or is it? Swift's version can do more than just spit out 0 or 1.

continue.reading(with: bool)

set

April 18, 2015

The array is a beautiful cornerstone of data structures, but sometimes we call upon its close cousin - the set. Here's how Swift's version works.

continue.reading(with: set)

int

April 11, 2015

Integers are used in almost every iOS app. With Swift, they've become even more useful.

continue.reading(with: int)

Looping and Iteration

March 29, 2015

It's one of the first thing green programmers learn - looping and iteration. Swift has made it easy and versatile.

continue.reading(with: Looping and Iteration)

Casting

March 20, 2015

We'd all just as soon let the compiler do all the work, but sometimes casting is unavoidable. Here's how it can be used with Swift.

continue.reading(with: Casting)

NSURLComponents

March 14, 2015

Picking apart and composing URLs becomes a more common programming task by the day. Foundation has a class specifically built for such situations.

continue.reading(with: NSURLComponents)

Tuples

March 08, 2015

Tuples can be a short stand in for tiny data constructs. When used properly, they can make your code a bit more opportunistic.

continue.reading(with: Tuples)