The Tech Guide

You're in the right spot to learn all about Swift, SwiftUI, UIKit and everything else about developing for Apple platforms. Here, I deep dive into interesting APIs, dish out quick tips and cover broader topics such as how to architect your app.

  • Swift Playgrounds 4 in Swift Playgrounds

    Xcode on the iPad is kinda sorta here! By way of Playgrounds, we can now realize our dream of creating apps on the iPad.

  • iOS 15 is coming in hot! Check out new ways to decode images, present sheets and more.

  • Apple has already shipped amazing things in the past month, so the floor is cleared. Let's gear up for a crazy dub dub with another official quiz!

  • iCloud is the gift that keeps on giving - both good and bad. Let's see how to leverage one of its best aspects today.

  • If you thought UIKit was getting pushed to the side with the rise of SwiftUI, you were wrong. There's a lot that's new, improved or revamped - let's take a look.

  • And here we go - iOS 14, SwiftUI tweaks and Catalyst fixes are on the way. It's time for another WWDC Pregame Quiz!

  • Lately, I've been researching more about effective Combine techniques. Today, I start in on utilizing Futures.

  • Keyboard and Combine in Tech Notes

    Handling the keyboard on iOS is a rite of passage if not also a little tiresome. Fortunately, Combine makes it better.

  • In my quest to pretty up some of the rougher edges of Spend Stack, today I turn my attention to styling my interface in Master-Detail Views. Easy to describe, harder to do.

  • Another core piece of functionality arrived in Swift 5.1 - built in diffing. Let's take a look.

  • Empty views are a critical piece of user experience on iOS. Today in tech notes, I explore how this might be done with diffable datasource.

  • Xcode Preview Snips in SwiftUI

    Xcode Previews for SwiftUI has quite literally changed a decade old workflow. Here are the techniques I currently live by.

  • The amount of power and engineering behind SwiftUI is extraordinary. Let's breakdown what's happening when one creates a new project using it.

  • Animating images is a common medium for communication in today's society. In iOS 13, Apple quietly offered us up a way to serve up .gifs or APNG files using ImageIO.

  • A LinkPresentation Introduction in LinkPresentation

    Say hello to a new framework shipping in iOS 13 that you've likely used hundreds of times as an end user. Now, rich link previews are available to all of us.

  • 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.

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

  • NSSecureCoding in Foundation

    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.

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

  • NS_CLOSED_ENUM in Swift

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

  • Optimizing Images in Image IO

    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.

  • 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.

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

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

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

  • NSPredicate in Foundation

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

  • UILayoutGuide in UIKit

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

  • 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.

  • NSMeasurement in Foundation

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

  • Copy on Write in Foundation

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

  • Device Check Overview in Device Check

    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.

  • 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.

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

  • SFAuthenticationSession in Safari Services

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

  • simctl in Misc

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

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

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

  • Global Functions in UIKit

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

  • Tail Call Elimination in Foundation

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

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

  • Swift Keywords in Swift

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

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

  • NS_SWIFT_NAME in Swift

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

  • noescape in Swift

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

  • 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.

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

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

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

  • On Learning iOS in Misc

    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.

  • #keyPath in Swift

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

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

  • 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.

  • Access Control in Swift

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

  • A Swift Refactor in Swift

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

  • 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?

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

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

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

  • ARC in Swift

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

  • Initialization in Swift

    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.

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

  • Option Set in Swift

    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.

  • Javascript in Swift

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

  • Error Handling in Swift

    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.

  • Guard in Swift

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

  • Defer in Swift

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

  • Quality of Service in Foundation

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

  • 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.

  • Pattern Matching in Swift

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

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

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

  • 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.

  • 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.

  • bool in Swift

    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.

  • set in Swift

    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.

  • int in Swift

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

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

  • Casting in Swift

    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.

  • NSURLComponents in Foundation

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

  • Tuples in Swift

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