Top-notch video tutorials for Swift developers

Sometimes we need menus to be dynamic, or we need to fetch some data before being able to build out the menu items. In this episode we will see how to leverage UIDeferredMenuElement to fetch some data and build a dynamic menu.

Last time we talked about the Encodable protocol. This time let's look at the Decodable protocol. We explore the general concept, then introduce zip and map as utilities to compose smaller decodings into larger ones.

We start exploring the concept of converting Encodable into an Encoding protocol witness. We discover how to clean up our code and make it fit in with `JSONEncoder`’s existing API. We then break down our example into smaller pieces and discuss how we can leverage pullback and functional composition to build bigger pieces out of smaller ones.

In the next few episodes we will explore the concept of Protocol Witnesses. This is an advanced topic that can be somewhat hard to approach, but in learning about Protocol Witnesses you will see how we can leverage the Swift language and functional programming to do some really cool things.

Let's see how we can provide a custom view controller to preview when a context menu is opened. This is analogous to (and a replacement for) the Peek/Pop interaction for devices that supported 3D Touch.

Another common use of context menus is with table views and collection views. In this episode we will explore adding a menu to a table view cell that allows copying a font or toggling it from a favorites list.

In this episode we will see how to nest menus inside each other as well as dynamically choosing when to show a nested menus contents inline.

Context menus are a great affordance for performing related actions to a UI element. Users can tap and hold to view the context menu, and the gesture is consistent across the OS so users will likely already be familiar with it. In this episode we'll show how to set up a basic context menu with a custom preview with normal and destructive actions.

This is a discussion and code overview of another implementation of mapping models using key paths with a special guest, Antoine van der Lee! In this episode we talk about his initial goals and constraints, and some of the design tradeoffs he made while designing a solution that would give him a bidirectional mapping between Core Data entities and other model types.

Ever wanted to translate from one type to another, for instance mapping from network models to core data objects? In this episode we will explore how to leverage Swift Keypaths to create a mapping between models. Along the way we'll run into a limitation of key paths and then talk about how to work around it.

Working with NSAttributedStrings can be a bit cumbersome, and can present some challenges when you want to localize your strings. We can make things much easier to work with by leveraging the BonMot library, which provides a cleaner interface for styling strings, allows us to separate styling from the views and strings, and customize tags we can use to mix styles in the same string.

Sometimes our text contains links that should be styled differently and react to taps so a URL can be opened in a web browser. While we can use a UILabel to detect and style links, they don't respond to touches. Let's see how we can leverage UITextView instead to handle links in NSAttribtedStrings.

To work with styled text we'll use NSAttributedStrings, which allow us to apply styles to ranges of text. Doing this in code is a bit more cumbersome than in storyboards, but allows us to control things like font size, color, style, kerning, line spacing and more.

The built-in way of adding constraints in code requires quite a bit of code and is a bit cumbersome to write. I believe that we should aim to reduce friction when writing code like this to make it easier to add new views and change your layout. SnapKit is a pretty useful dependency that gives you a DSL for making autolayout constraints. In this episode we'll integrate SnapKit into the project and simplify our existing layout code.

If you look at our view controller now, it is full of code that mostly is dealing with constraints, subviews, and overall layout. This is really the job of the view. In this episode we will extract this into a new view class. We'll also introduce a reusable base class that will handle the required view initializer dance for us, making the job of creating custom view classes a bit easier.

One really useful UIView subclass I generally have on all my projects is a simple GradientView. You give it two colors and optionally some location values and it draws a gradient from top to bottom. In this episode we build this so that we can integrate a fade to black effect to overlay on top of the background image.

In this episode we will see how we can leverage SwiftUI's live previews even if we aren't using SwiftUI and even if our deployment target is less than iOS 13! We'll cover previewing our view controllers and using that to give us rapid feedback on our layout as we work.

When working on a project that doesn't use Storyboards, we have to create our window and root view controller manually. iOS 13 introduced the concept of Scene Delegates, which change how this is typically set up. In this episode we will review how to set up a new project, remove the storyboard references, and set up the window and root view controller in code.

Imagine you're building an app that will consume an API, however the API is not ready yet. The server team has given you some sample responses as JSON files you can use to start working against. In this episode we'll examine a useful technique of registering a custom URLProtocol for intercepting and handling network requests. We can use this fake server to continue building out our network infrastructure without being dependent on the backend API.

One of the quickest ways for an app to give some personality and branding is to customize the type of buttons in the app. Out of the box iOS gives us a rather uninspiring blue label that is known to be a button, but it is common for apps to have their own button design. In this episode we will take a stylized button design from Dribbble and implement it as a custom component. We'll build it in a playground so we can see our work quickly, and we'll create custom previews (similar to SwiftUI) for viewing multiple states of the button at the same time.

Now that we have some streaming output from the ffmpeg process, we can take this and create a custom progress bar. Since this could useful in other utilities we can create it as a separate Swift package and import it using a local file reference.

When dealing with long running tasks it would be nice to be able to gather output as the task runs and not hang until the entire process is done. In this episode we will extract some useful information out of ffprobe, so we can get the total number of frames in a video file, and then kick off ffmpeg to encode the video. We'll use the Subprocess package to provide a simpler interface over gathering output from a pipe as it is sent, rather than waiting for the end.

I always like it when command line programs offer colored output, which helps to discern between various stages of output, highlight errors and other important information. This is done with ANSI color codes, which are a somewhat archaic technique, but we can implement a nice wrapper to make it easy to work with in Swift.

In this episode we will launch other programs as sub processes and show how to capture its output.