Top-notch video tutorials for Swift developers

In this episode, I am thrilled to be joined by Matt Massicotte to kick off the "1 Billion Row Challenge" in Swift. The goal is to efficiently parse a massive file containing weather station data and calculate the min, max, and mean temperatures for each city. We set up a Swift package, explore basic file I/O methods, memory mapping, chunked reading, and implement a naive solution that processes the data and sets the stage for significant optimization in upcoming episodes.

As the project grows, Xcode has to compile more and more code. Our code is already modularized, and there are plenty of occasions where we don't want to continuously rebuild everything. This is especially true for external frameworks. In this episode we take advantage of tuist cache to generate precompiled binaries to link with, making our builds lightning fast.

We create our project with Tuist and examine the various manifest files that define our project. We then create a new target and discuss how you can leverage the fact that Tuist manifests are just Swift files. We also change around the folder structure of our project, which is something that is generally painful to do with plain Xcode projects.

In this episode, we explore parsing strings into structured data using the Swift parsing library from Point Free. We demonstrate how to create composable parsers, starting with a simple example, then build a couple more complex parsers, including one for parsing sample input from Advent of Code and another for parsing CSV data of taxi trips. We'll explore how to use both forms of parsers and lean on composability to build them up.

In this episode, we explore the Swift Clock protocol, particularly the utility in testing and Xcode previews. Clocks are essential for managing time-related functionality in code but can complicate tests and previews by causing delays. By creating custom clocks, developers can control time advancement and sleeping, making tests and previews more efficient. Two custom clocks are implemented: an ImmediateClock and a ScaledClock. These allow you to bypass or scale the delay, allowing for quicker iterations in previews. The Immediate Clock skips delays entirely, while the Scaled Clock speeds up the delay by a specified factor. These custom clocks can also be used in tests to avoid unnecessary waiting, enhancing development efficiency.

In this episode we cover migrating our Swift Data models between incompatible versions using custom and lightweight migration.

SwiftData is a replacement for CoreData, built entirely for Swift. It leverages the underpinnings of Core Data, but is much simpler to work with. In this video we will cover the first 3 main types you'll need to understand: ModelConfiguration, ModelContainer, and ModelContext.

In this episode we take a look at the newly announced Swift Testing framework that is currently in preview. This leverages Swift Macros to make tests much more friendly to write, gives you much richer diagnostic information when tests fail, and is generally a welcome improvement over using XCTest. Keep in mind this is a preview at the time of recording and will require a snapshot toolchain of Swift.

We start looking at SwiftUI on the Mac. We'll go over how document-based apps work, and see how much functionality and standard behavior we can get with just a few lines of code. This will be the basis for a new app we'll make called Memeify.

Storing secrets in plain-text in your source code is not a great idea. It can lead to leaking this information to the wrong people (or to a wider audience than is necessary), it makes rotating these keys difficult, and it makes it trivial for people to see these secrets in your compiled application binary. In this episode we will utilize an obfuscation approach that may just be good enough for many use cases.

When working on a large project with multiple developers, we often find ourselves in contention with the Xcode project.pbxproj file. Conflicts here are not easy to solve manually, and if you make a mistake Xcode won’t load the project at all, requiring you to fix it manually. In this episode we will explore migrating to a solution where the project file is generated using a tool called Xcodegen.

In this episode we fix an issue that caused our sorting logic to be lost after adding persistence.

Property Wrappers are great for encapsulating cross-cutting concerns and simplifying common patterns. However, previously it seemed impossible to access the enclosing instance to enable more advanced and useful behaviors. As it turns out, this was supported all along, just in a not-so-obvious way. Let me show you.

There are a number of types, propertyWrappers and view modifiers describing "focus" so it is not immediately obvious what they are all for. In this episode we will see how we can control focus for a text field in SwiftUI. We'll see how to use simple Bools as well as your own types to describe which field has focus. Finally we'll touch on a common request that doesn't yet have a great answer: setting focus in onAppear.

iOS 14 brought some nice improvements to os_log via a new type called Logger. This leverages Swift's StringInterpolation type to make it much more usable for formatting values inside your logs. It does this without sacrificing the privacy and performance that makes os_log so appealing. In this episode we will see how we can adopt this new API as well as how StringInterpolation works under the hood.

In this episode we create an image cache using an actor that provides disk-caching for images from the Unsplash API. We'll also talk about Sendable and enable some compiler warnings to help us catch potential issues.

The unit of work in Swift Concurrency is the Task. In this episode we will see how tasks are created and structured, how to run work in parallel, and how to handle cancellation by aborting work or returning partial results.

Actors are a new first class concept in swift. In this episode we will explore the problem they solve and how to use them to avoid race conditions which can lead to inconsistent results or even crashes.

With Continuations we can bridge the non-async world and make it async. Continuations allow us to take the result of a completion block and turn it into an async flow. In this episode we will see the difference between checked and unchecked continuations as well as their throwing variants.

In this episode we will see how URLSession can be used with async await. With this new API you can easily send network request and await a tuple of both the data and the response object.

If you're using CocoaPods already, then mixing with Swift Packages can prove to be infeasible. You can create your modules as internal pods as well, however there are a few gotchas. In this episode I will cover how to do this, how to link up local pods and create example projects for demo UI and running tests, as well as how to overcome some of the rough edges you might experience.

Now that we've seen how to setup a feature module, we'll also need to decide how best to share a feature's resources and deal with dependencies.

One big benefit of modularizing an application is working on features as modules. Let's re-create the welcome screen experience as a feature module using Swift Package Manager and Xcodegen.

In this episode we create a modularized setup where our modules are Swift Packages and brought into the main app using Xcodegen and local path references to the packages.