Top-notch video tutorials for Swift developers

Once we have our translated files back from our translators, we can now import them for use in our project. I'll show how do do this within Xcode and from the command line.

In this episode I will show two ways you can export all of the strings in your project. The first is using Xcode, but since this is a process you'll likely want to repeat, we'll also show how to do it via the command line so you can automate it. We'll then take the xliff files and send them off for translation using a translation service.

There's a bit of prep work we need to do to get our project ready to be localized. We'll start by defining which languages we want to support, localize any interface-based files like Storyboards, and then move on to localizing strings in code.

Using DateFormatter we can format dates and times to whatever format we choose. However, in most cases we should rely instead on the builtin styles instead, which are locale aware. This way we can present dates and times that are consistent with the user's preferences.

Let's quickly review how to work with the Locale object. Then we can use various locales in conjunction with NumberFormatter and ListFormatter to have localized output provided for us.

In this episode we will define what Localization is and why you should localize your apps.

One of my favorite new features of Xcode 13 is support for Vim key bindings. In this episode we will see how to enable this and I'll give a quick tour of how to get around using Vim.

In this episode we introduce a new open source library called Swift Coding that takes all of these concepts and wraps it up into a Swift Package you can use in your own projects. We give a tour of what the library can do and how you can use it.

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.