Tiny Networking Library
We make use of Swift's generics and structs to build a simple network layer with great testability.
Episode 1 · Jun 17, 2016
Swift Talk
All Episodes
97 Episodes shown Oldest First
Clear Filters-
Networking -
Functional Programming Rendering CommonMark
We create attributed strings from CommonMark. We continually refactor our code to make the central logic short and understandable.
Episode 2 · Jun 17, 2016
-
Networking Loading View Controllers
We explore different approaches to factor out asynchronous loading code from view controllers, using protocols, container view controllers, and generics.
Episode 3 · Jun 24, 2016
-
Functional Programming Rendering CommonMark (Part 2)
We add customizable styles to our CommonMark renderer from episode #2.
Episode 4 · Jul 1, 2016
-
Architecture Connecting View Controllers
We refactor our code by moving the app's flow from the storyboard into a separate coordinator class. This avoids view controllers having implicit knowledge of their context.
Episode 5 · Jul 8, 2016
-
Table Views Generic Table View Controllers
We leverage Swift's generics to keep our table view controller code clean.
Episode 6 · Jul 15, 2016
-
Architecture Stack Views with Enums
We create an abstraction around stack views using enums to specify UI elements in a declarative style.
Episode 7 · Jul 22, 2016
-
Networking Adding POST Requests
We add POST support to a simple networking layer, using Swift's enums with associated values and generics.
Episode 8 · Jul 29, 2016
-
Q&A
In this episode, we answer some of the questions we've received over the past few weeks. We cover networking, table views, stack views, our App class, and testing.
Episode 9 · Aug 5, 2016
-
Ledger Mac App Introduction
We give a quick introduction to Ledger itself and to the Mac app we're going to build.
Episode 10 · Aug 12, 2016
-
Ledger Mac App Evaluating Expressions
Expressions are at the heart of Ledger. We write an evaluator for this expression language in a test-driven way.
Episode 11 · Aug 12, 2016
-
Ledger Mac App Evaluating Transactions
Writing the code for evaluating transactions required continuous refactoring to keep our code simple and clean.
Episode 12 · Aug 19, 2016
-
Ledger Mac App Parsing Techniques
We look at two different techniques to parse a simple expression language: handwritten parsers and parser combinators.
Episode 13 · Aug 26, 2016
-
Ledger Mac App Growing Trees with Classes and Structs
We build a tree structure from an array of Ledger account names. We first implement the tree using a class, and then we refactor it to a struct and discuss the differences and tradeoffs involved.
Episode 14 · Sep 2, 2016
-
Ledger Mac App Building Parser Combinators (Part 1)
Join us in the functional programming gym to stretch your object-oriented comfort zone while we lay the groundwork for a parser combinator library.
Episode 15 · Sep 9, 2016
-
Ledger Mac App Building Parser Combinators (Part 2)
We implement some of the more challenging parts of parser combinators.
Episode 16 · Sep 16, 2016
-
Ledger Mac App Architecture
We connect multiple view controllers using a coordinator and callback functions. We simplify the control flow by refactoring the UI state into its own struct.
Episode 17 · Sep 23, 2016
-
Ledger Mac App Adding Search
We leverage the existing infrastructure of our app to add a search field with very little code.
Episode 18 · Sep 30, 2016
-
Functional Programming From Runtime Programming to Functions
We build a flexible sort descriptor abstraction on top of Swift's native sort methods, which is dynamic and type safe.
Episode 19 · Oct 7, 2016
-
Swift, the Language Understanding Value Type Performance
We use copy-on-write to write an efficient struct wrapper around NSMutableData and discuss how the standard library uses the same approach.
Episode 20 · Oct 14, 2016
-
Swift, the Language Structs and Mutation
We can change structs by mutation, functional chaining, and inout parameters. We discuss how they differ at the call site and why they’re all equivalent.
Episode 21 · Oct 21, 2016
-
Command Line Tools with Swift
We show how we build simple command line tools leveraging the Cocoa frameworks. We use the Swift Package manager to include dependencies in our project.
Episode 22 · Oct 28, 2016
-
Splitting Arrays
We talk about a familiar but surprisingly tricky problem: splitting an array into groups of elements. We discuss the pros and cons of our own solutions along with the solutions people sent us via Twitter!
Episode 23 · Nov 4, 2016
-
Architecture Delegates & Callbacks
We discuss the pros and cons of delegates versus callback functions and why delegate protocols are always class only.
Episode 24 · Nov 11, 2016
-
Networking Adding Caching
We add support for caching network requests without altering our original networking abstraction.
Episode 25 · Nov 18, 2016
-
Table Views Generic Table View Controllers (Part 2)
We build a generic, type-safe table view controller that can handle multiple cell classes.
Episode 26 · Nov 25, 2016
-
Type-Safe API Wrappers Typed Notifications (Part 1)
A lightweight generic wrapper around Foundation's notification API lets us avoid boilerplate code and provides a type-safe API.
Episode 27 · Dec 2, 2016
-
Type-Safe API Wrappers Typed Notifications (Part 2)
We extend our notification wrapper from episode #27 and discuss an alternative protocol-based approach.
Episode 28 · Dec 9, 2016
-
Swift, the Language Protocols & Class Hierarchies
We refactor a class hierarchy using a protocol and discuss the differences between both approaches.
Episode 29 · Dec 16, 2016
-
Interfaces
We talk about the importance of types and interfaces as tools to express your intent precisely and to set the proper boundaries.
Episode 30 · Dec 30, 2016
-
Swift, the Language Mutating Untyped Dictionaries
Mutating a nested untyped dictionary can be a challenge. To solve it we discuss the mutability of value types and the concept of l-values.
Episode 31 · Jan 6, 2017
-
Collection Protocols Array, ArraySlice & Collection
We show how to use the Collection protocol to make an extension available not just on array, but on all collections.
Episode 32 · Jan 13, 2017
-
Collection Protocols Sequence & Iterator
We make our collection extension even more generic by implementing it on the Sequence protocol.
Episode 33 · Jan 20, 2017
-
Reactive Programming Reactive Programming
We take a look at how reactive programming challenges us to think differently.
Episode 34 · Jan 27, 2017
-
Collection Protocols Sorted Arrays
We build a sorted array type on top of Swift's native array and make it conform to the Collection protocol.
Episode 35 · Feb 3, 2017
-
Reactive Programming Futures
We implement a Futures type that we can use instead of callbacks as a first step towards a reactive library.
Episode 36 · Feb 10, 2017
-
Collection Protocols Building a Custom IndexSet Collection
We build the basics for a custom index set collection type.
Episode 37 · Feb 17, 2017
-
Collection Protocols Conforming IndexSet to Sequence
Conforming to the Sequence protocol allows us to efficiently iterate over the elements, and we gain all of its useful functionality.
Episode 38 · Feb 24, 2017
-
Reactive Programming From Futures to Signals
We extend the Future type of a previous episode to a simple reactive library. Along the way, we dive into debugging a reference cycle in our implementation.
Episode 39 · Mar 3, 2017
-
Reactive Programming Signal Ownership and Subscriptions
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.
Episode 40 · Mar 10, 2017
-
Collection Protocols Conforming IndexSet to Collection
To conform IndexSet to the Collection protocol we implement a custom index type along the way.
Episode 41 · Mar 17, 2017
-
Reactive Programming Thread Safety
We make our Signal implementation thread-safe by safeguarding the access to shared resources.
Episode 42 · Mar 24, 2017
-
Architecture View Controller Refactoring
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.
Episode 43 · Mar 31, 2017
-
Server-Side Swift Setting Up a Server-Side Swift Project
We set up our development environment using the Swift package manager and Docker.
Episode 44 · Apr 7, 2017
-
Server-Side Swift Routing
We implement a type safe and Swift-like routing infrastructure that's pretty different from the common approach of most web frameworks.
Episode 45 · Apr 14, 2017
-
Swift, the Language Combined Class and Protocol Requirements
We look at multiple ways to create variables that have a class type but also conform to a protocol.
Episode 46 · Apr 21, 2017
-
iOS at Kickstarter View Models
Brandon from Kickstarter shows us how they write highly testable code with view models. We integrate Apple Pay payments and look at their open-source codebase.
Episode 47 · Apr 28, 2017
-
Server-Side Swift Interfacing with PostgreSQL
We implement a lightweight wrapper around the libpq C library.
Episode 48 · May 5, 2017
-
iOS at Kickstarter Deep Linking
Brandon from Kickstarter shows their approach of unifying all potential entry points into an iOS app using a common route enum, both in a simple demo implementaion and in their open source code base.
Episode 49 · May 12, 2017
-
Server-Side Swift Interfacing with PostgreSQL (Part 2)
We extend our libpq wrapper to handle queries with properly escaped parameters. To achieve this, we have to dive deep into Swift's unsafe pointer APIs.
Episode 50 · May 19, 2017
-
iOS at Kickstarter Playground-Driven Development
Brandon from Kickstarter demos how the company uses playgrounds to prototype and style individual view controllers.
Episode 51 · May 26, 2017
-
Swift, the Language Deleting Code with Swift 4
Swift 4's new features lets us delete code we've written in previous episodes.
Episode 52 · Jun 2, 2017
-
iOS at Kickstarter Test-Driven Reactive Programming
Lisa from Kickstarter shows us their test-driven development process to reactive programming.
Episode 53 · Jun 9, 2017
-
Architecture UI Elements with Callbacks
We write a dedicated target-action to make it easier to augment existing UI controls with callbacks.
Episode 54 · Jun 16, 2017
-
Data Structures Sorted Arrays with Binary Search
Together with Károly, we improve our sorted array implementation using binary search. We benchmark both implementations to learn about their real-world performance.
Episode 55 · Jun 23, 2017
-
Data Structures Binary Search Trees
We look at binary search trees as an alternative to last episode's sorted array implementation. We benchmark the performance of insertion and lookup in both data structures, with some surprising results.
Episode 56 · Jun 30, 2017
-
Certificate Pinning
Today we're joined by Rob Napier, who explains why and how to add certificate pinning to your app.
Episode 57 · Jul 7, 2017
-
Data Structures Red-Black Trees
Building on the binary search tree code from episode #56, we implement red-black trees as self-balancing tree data structures and benchmark their performance.
Episode 58 · Jul 14, 2017
-
Tooling Refactoring with Xcode 9
We take a look at features like renaming, extracting expressions, extracting methods, and more.
Episode 59 · Jul 21, 2017
-
Tooling Xcode 9 Productivity Tips
We show some of our favorite new productivity features in Xcode 9.
Episode 60 · Jul 28, 2017
-
Experiments Mutable Shared Structs (Part 1)
We recap the tradeoffs between classes and structs and start implementation of our new type, leveraging Swift 4's keypaths.
Episode 61 · Aug 4, 2017
-
Architecture Testable View Controllers with Reducers
We show the reducer pattern to simplify state management and to make typical view controller code more testable.
Episode 62 · Aug 11, 2017
-
Experiments Mutable Shared Structs (Part 2)
We refine the observation capabilities of our new data type.
Episode 63 · Aug 18, 2017
-
Table Views Driving Table View Animations
We build a component similar to NSFetchedResultsController to decouple our view data and to drive table view animations.
Episode 64 · Aug 25, 2017
-
Data Structures Playground QuickLook for Binary Trees
We create a custom Quick Look extension to visualize binary tree structures in playgrounds.
Episode 65 · Sep 1, 2017
-
Architecture The Elm Architecture (Part 1)
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.
Episode 66 · Sep 8, 2017
-
Reactive Programming Reactive Data Structures: Linked Lists
We build a reactive linked list on top of reactive programming primitives. We implement a reduce method on this type, which does the minimum amount of work when the underlying data changes.
Episode 67 · Sep 15, 2017
-
Architecture The Elm Architecture (Part 2)
We extend our Elm-style app with a more dynamic view hierarchy by adding a navigation controller and a table view.
Episode 68 · Sep 22, 2017
-
Reactive Programming Reactive Data Structures: Arrays
We build a reactive array type on top of the reactive list from episode #67 and implement a filter method.
Episode 69 · Sep 29, 2017
-
Reactive Programming Table View Animations with Reactive Arrays
We use the reactive array type from episodes #67 and #69 to back a table view. This allows us to correctly animate changes in the underlying data, even with filter and sort transformations applied.
Episode 70 · Oct 6, 2017
-
Swift, the Language Type-Safe File Paths with Phantom Types
Brandon Kase joins us to show how Swift's type system can be leveraged to check file paths at compile time.
Episode 71 · Oct 13, 2017
-
Architecture Adding a Custom View to a View-State Driven App
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.
Episode 72 · Oct 20, 2017
-
Experiments View Bindings in Pure Swift
We experiment with reactive view bindings that don't rely on runtime programming.
Episode 73 · Oct 27, 2017
-
Experiments View Bindings in Pure Swift (Part 2)
We continue to expand our experimental view binding mechanism to implement dark mode in our app.
Episode 74 · Nov 3, 2017
-
Swift, the Language Auto Layout with Key Paths
We clean up our layout code by introducing helper functions that leverage Swift's key paths.
Episode 75 · Nov 10, 2017
-
Incremental Programming Understanding Reactive Glitches
We look at an example of a reactive pipeline with surprising behavior, discuss why it occurs, and how it could be improved.
Episode 76 · Nov 17, 2017
-
Incremental Programming A Technique to Avoid Reactive Glitches
We refactor the simple reactive library from the last episode using topological sorting to avoid any temporarily wrong values.
Episode 77 · Nov 24, 2017
-
Swift, the Language Swift Strings and Substrings
We write a simple CSV parser as an example demonstrating how to work with Swift's String and Substring types.
Episode 78 · Dec 1, 2017
-
Swift, the Language String Parsing Performance
We benchmark the CSV parsing code from the previous episode and refactor it to become an order of magnitude faster.
Episode 79 · Dec 8, 2017
-
Swift, the Language Swift String vs. NSString
We look at how to work with ranges in a mixed Swift String/NSString environment.
Episode 80 · Dec 15, 2017
-
Incremental Programming Reference Cycles and Ownership
We use Xcode's memory debugger to resolve all the reference cycles in our glitch-free reactive code and introduce a proper ownership model.
Episode 81 · Dec 22, 2017
-
Functional Programming Refactoring Imperative Layout Code
We refactor a simple flow layout to have a functional interface, disentangling the layout code from UIKit code.
Episode 82 · Jan 5
-
Libraries Wrapping Analytics APIs
We look at different techniques for wrapping analytics APIs in Swift and discuss their advantages and disadvantages.
Episode 83 · Jan 12
-
Architecture Introducing Our New Book: App Architecture
Today we're releasing the early access edition of our new App Architecture book. We explain how it came about, what's in it, and how early access works.
Episode 84 · Jan 19
-
Type-Safe API Wrappers Wrapping libgit2
We write a wrapper around the libgit2 C library to work with Git repositories from macOS and iOS apps — and for the fun of using Swift's pointer APIs!
Episode 85 · Jan 26
-
Architecture Sharing State between View Controllers in MVC (Part 1)
We add a mini player to the MVC variant of the sample app found in our App Architecture book. We adjust our storyboard and discuss how to adapt the architecture.
Episode 86 · Feb 2
-
Architecture Sharing State between View Controllers in MVC (Part 2)
We continue implementing a mini player in the MVC variant of the sample app found in our App Architecture book.
Episode 87 · Feb 9
-
Libraries Extensible Libraries 1: Enums vs Classes
We discuss the capabilities and limitations of enums and classes when designing extensible libraries.
Episode 88 · Feb 16
-
Libraries Extensible Libraries 2: Protocol Composition
We show how protocol composition can be used to design extensible libraries, thereby solving the so-called "Expression Problem."
Episode 89 · Feb 23
-
Functional Programming Concurrent Map
We implement a concurrent version of the map method for arrays.
Episode 90 · Mar 2
-
Libraries Rendering Markdown with Syntax Highlighting
We extend a basic Markdown library using protocol composition to add support for syntax highlighting in Swift code blocks
Episode 91 · Mar 9
-
Swift, the Language Practicing with Pointers
We use Swift's pointer APIs to read a text file and split it into lines without using Swift's collection and string types.
Episode 92 · Mar 16
-
Swift, the Language Handling Optionals
We discuss many considerations and techniques for working with optionals.
Episode 93 · Mar 23
-
Building a Form Library Building a Form Library: Introduction
This episode marks the beginning of a new series where we refactor a hand-coded settings form into a reusable, declarative form library. In this episode, we build the base version and discuss the design goals of the library.
Episode 94 · Mar 30
-
Building a Form Library Building a Form Library: Simplifying IndexPath Logic
We begin to refactor the imperative table view code from the last episode, working toward a more declarative approach of defining our form.
Episode 95 · Apr 6
-
Building a Form Library Building a Form Library: Extracting a Reusable Form View Controller
We continue refactoring our forms code by creating a form table view controller as the first reusable component.
Episode 96 · Apr 13
-
Building a Form Library Building a Form Library: Creating a Reusable Form Driver
We refactor the form driver class to be reusable and define the entire form in a simple function.
Episode 97 · Apr 20