Swift Talk

A weekly video series on Swift programming.

Subscribers-Only

Subscribers Only

#74 View Bindings in Pure Swift (Part 2) 21:09

We continue to expand our experimental view binding mechanism to implement dark mode in our app.

#73 View Bindings in Pure Swift 22:12

We experiment with reactive view bindings that don't rely on runtime programming.

Subscribers-Only

Subscribers Only

#72 Adding a Custom View to a View-State Driven App 33:31

We introduce a project we're going to work on over a few episodes. To get familiar with the code, we build a new feature using the app's view-state driven approach.

Subscribers-Only

Subscribers Only

#68 The Elm Architecture (Part 2) 24:59

We extend our Elm-style app with a more dynamic view hierarchy by adding a navigation controller and a table view.

Subscribers-Only

Subscribers Only

#66 The Elm Architecture (Part 1) 16:39

We refactor our reducer-based project from episode #62 to use The Elm Architecture. Instead of interacting with UIKit directly, we build a virtual view hierarchy and let our Elm framework do the rest.

Subscribers-Only

Subscribers Only

#62 Testable View Controllers with Reducers 31:00

We show how the reducer pattern can be used to make typical view controller code more testable.

#49 Deep Linking at Kickstarter 27:11

Brandon from Kickstarter joins us to discuss deep linking into an iOS app. We show how to unify all potential entry points into the app using a common route enum, and then we take a look at this pattern in Kickstarter's open source codebase.

#47 View Models at Kickstarter 33:58

Brandon from Kickstarter joins us and shows how the company uses view models to write highly testable code. We integrate Apple Pay payments and look at Kickstarter's open-source codebase.

#43 View Controller Refactoring 16:52

We refactor some view controller logic while working on our upcoming tvOS app. Instead of letting multiple view controllers manage the navigation bar's state individually, we pull this code out and unify the logic in one place.

Subscribers-Only

Subscribers Only

#42 Thread Safety (Reactive Programming #5) 23:36

We make our Signal implementation thread-safe by safeguarding the access to shared resources.

Subscribers-Only

Subscribers Only

#40 Signal Ownership and Subscriptions (Reactive Programming #4) 16:28

We add the ability to map over signals and control subscriptions in a more fine-grained manner. Along the way, we improve the signal ownership model and implement the concept of disposables.

#39 From Futures to Signals (Reactive Programming #3) 23:45

We build upon the Future type of a previous episode to implement a simple reactive library. Along the way, we dive into debugging a reference cycle in our implementation.

Subscribers-Only

Subscribers Only

#34 Reactive Programming 26:12

We take a look at reactive programming and see how it challenges us to think differently.

Subscribers-Only

Subscribers Only

#30 Interfaces 16:07

We talk about the importance of types and interfaces as tools to express your intent precisely and to set the proper boundaries.

  1. Generics
  2. Architecture
  3. Types
December 30, 2016

#29 Protocols & Class Hierarchies 16:02

We refactor a class hierarchy using a protocol and discuss the differences between both approaches.

#25 Network Caching 23:33

We come back to our unfinished Swift Talk iOS app and implement a lightweight network cache for offline support. We keep our networking code from episode #1 untouched to maintain a clear separation of concerns.

Subscribers-Only

Subscribers Only

#24 Delegates & Callbacks 15:29

We discuss the pros and cons of delegates versus callback functions and why delegate protocols are always class only.

Subscribers-Only

Subscribers Only

#18 Adding Search to the Ledger GUI App 16:00

In this episode, we implement search functionality for our Ledger GUI app. In the process, we leverage several aspects we've talked about before, such as connecting view controllers, managing application state, and parsing user input.

  1. Parsing
  2. Architecture
September 30, 2016

#17 Ledger GUI Architecture 18:31

We connect multiple view controllers using a central coordinating object and callback functions. Then we refactor the UI state into its own struct to simplify the control flow.

Subscribers-Only

Subscribers Only

#8 Networking: POST Requests 18:40

We extend the networking code from the first episode to support POST requests. Besides using Swift's enums with associated values and generics, we get to implement a map function on a custom data type.

#5 Connecting View Controllers 20:14

We refactor our code by moving the app's flow from the storyboard into a separate class. Our goal is to manage the view controller flow from a central place so that view controllers don't have implicit knowledge of their context.

#1 Networking 22:49

We explore an alternative approach to building the networking layer of an app. We make use of Swift's generics and structs to end up with simple, testable code.