Swift Talk

A weekly video series on Swift programming.

#76 Understanding Reactive Glitches 18:16

We look at an example of a reactive pipeline with surprising behavior and discuss why it occurs and how it could be improved.

  1. Algorithms
  2. Reactive
November 17, 2017
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

#70 Table View Animations with Reactive Arrays 15:26

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.

#69 Reactive Data Structures: Arrays 30:55

We build a reactive array type on top of the reactive list from episode #67 and implement a filter method.

  1. Collections
  2. Reactive
  3. Structs
  4. Types
September 29, 2017

#67 Reactive Data Structures: Linked Lists 25:58

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.

  1. Enums
  2. Collections
  3. Reactive
  4. Types
September 15, 2017

#53 Test-Driven Reactive Programming at Kickstarter 38:47

This week Lisa joins us to demonstrate the test-driven approach to reactive programming taken at Kickstarter.

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

#36 Futures (Reactive Programming #2) 17:30

We look at implementing a Futures type that we can use instead of callbacks. This is the first step toward a simple implementation of a reactive library.

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.