Top-notch video tutorials for Swift developers

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.

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.

One thing that can be a pain when splitting modules up into separate projects is maintaining the Xcode projects themselves. Not to mention the fact that as team sizes grow, merging changes in project files gets exponentially more painful. In this episode we will look at using Xcodegen to have a repeatable project generation that you can use to create consistent Xcode projects without much fuss.

Now that Swift Package Manager has started to see some adoption and we have some integration inside of Xcode, I think it's time to take a deeper look at how to use it both as a consumer and as a library author. In this episode we'll create a DiceKit library using SwiftPM, then use it in a command line utility.

The new default shell in macOS Catalina is zsh. If you're like me and have been using Bash for years, this is probably a good time to make the switch. In this episode I will go over installing zsh, adding a little configuration as well as some of the features it has over bash. I'll also install oh-my-zsh and customize my prompt using Powerline fonts. Finally I'll import some well-used Bash aliases and functions that I've used for years.

We continue our mini-project to create a Swift script that automatically creates migrations for Vapor projects. In this episode we save the generated templates to disk, render a generated extension so that we can add these migration types to the Vapor service, and see the example running end-to-end.

Usually I lean on Ruby or Bash for writing command line scripts, but it is becoming increasingly more viable to use Swift for this as well. In the Vapor series, I wanted to write a little script (in Swift) that would generate migration files for me so I wouldn’t have to maintain this myself. For this, I used the Marathon tool, which helps alleviate some of the machinery necessary to use Swift in this way. And what better way to explore this tool than with this author guiding me along. John Sundell joins me in this episode to use Marathon and Swift to write a useful script for Vapor applications. This is a longer episode, so it is split into two parts. Enjoy!

In this episode we cover the concept of expectations, which enables us to test asynchronous code, properly timing out and failing a test if the expectation is never fulfilled.

In this episode we setup our Xcode preferences and themes.

In this episode we install homebrew, a popular package manager. We use it to install Macvim and ruby. We also setup Postgres with Postgresapp.

In this episode we configure git to identify our commits, set up a diffing & merging tool, and configure SSH so we can log into other machines securely.

In this episode we configure iTerm’s keyboard behavior to match macOS to allow for quick jumping between words in the terminal.

In this episode, we set up our dotfiles to customize aspects of bash, git, vim, and other terminal programs that are core to a good terminal experience.

Managing external beta users can be a bit of a chore, as you have to log into iTunes Connect and add them one by one (or a batch if you have them collected already). If you’re opening your beta to a wider audience, you can save a lot of time by automating it. In this episode we will use Fastlane Boarding to automate adding testers to Testflight.

In this episode we will setup iTerm2, profiles, custom color schemes, and fonts.

Our applications often depend on 3rd party services that require API tokens, Client IDs & Secrets, Passwords and other sensitive data. This data should not be checked into your source repository for numerous reasons. Having control over who has access to keys is important, especially for larger organizations. In this episode I will show you one technique for managing these keys without having to check them into git.

Writing boilerplate code can get tedious and boring. It can also lead to code duplication, which means it becomes a liability to keep in sync. Sourcery is a code generation tool that can help leverage your existing types and reflect on them in order to generate useful bits of code. In this episode Sam Soffes shows us how to install and use Sourcery, how to integrate it with Xcode’s build system, and how to create a simple Sorcery template to automatically count the number of items in a Swift enum and add it as an option.

Logging is an important part of diagnosing issues in our application. Unfortunately, once they've shipped it's difficult to retrieve these logs to help identify issues with our released software. In this episode I'll take a look at SwiftyBeaver, a library that aims to make logging easy and accessible. We'll show how you can separate log messages by severity, selectively log some messages to the Xcode Console, some messages to a file, and sending them encrypted to the SwiftBeaver cloud platform for viewing with their provided viewer application.

When doing release builds it is handy to automatically update the build number so we always have a unique version for reporting bugs. However it is not easy for testers to always know which version they are testing. In this episode we'll look at how to set up versioning for our project, automatically increment the versions number for release builds, and badge our application's icon so it is easy to see which version of the app you have installed.

In this episode we set up fastlane to automate a lot of the tedious tasks related to building and deploying iOS applications. We use it to create our bundle identifier, create certificates and provisioning profiles, build and test our app, take screenshots on multiple devices, and submit to TestFlight.

Sam Soffes joins us again to talk about supporting Carthage for your own libraries. In the demo, you'll also see how to structure a project to include both Mac and iOS framework targets with a single Xcode project.

In this episode we welcome our first ever guest screencaster, Sam Soffes! Sam takes us through what it takes to get started with Carthage to manage dependencies. Sam compares Carthage's approach to CocoaPods and walks through how to bring in a 3rd party library into a project.