All Collections

29 Collections

SwiftUI

190 Episodes · 66h05min
- SwiftUI as Static Site Generator (Part 5) 21:21
- SwiftUI as Static Site Generator (Part 4) 28:18
- SwiftUI as Static Site Generator (Part 3) 20:58
- SwiftUI as Static Site Generator (Part 2) 20:38
- SwiftUI as Static Site Generator (Part 1) 22:16
- Building a Token Field (Part 5) 27:40
- Building a Token Field (Part 4) 16:06
- Building a Token Field (Part 3) 19:05
- Building a Token Field (Part 2) 25:12
- Building a Token Field (Part 1) 23:10
- Building a FaceTime-like Animation (Part 2) 18:48
- Building a FaceTime-like Animation (Part 1) 16:08
- Staggered Animations Revisited (Part 3) 14:03
- Staggered Animations Revisited (Part 2) 16:31
- Staggered Animations Revisited 00:00
- Custom Format Styles 20:31
- Text Formatting 21:13
- Keeping Local View State in Sync 19:35
- Optional Bindings 27:15
- Attribute Graph (Part 10) 17:10
- Attribute Graph (Part 9) 32:16
- Attribute Graph (Part 8) 20:57
- Attribute Graph (Part 7) 23:53
- Attribute Graph (Part 6) 25:44
- Attribute Graph (Part 5) 28:20
- Attribute Graph (Part 4) 26:32
- Attribute Graph (Part 3) 20:10
- Attribute Graph (Part 2) 22:12
- Attribute Graph (Part 1) 20:35
- Particle Effects (Part 6) 15:02
- Particle Effects (Part 5) 12:37
- Particle Effects (Part 4) 21:04
- Particle Effects (Part 3) 18:16
- Particle Effects (Part 2) 16:25
- Particle Effects (Part 1) 14:28
- Lazy Container Views (Part 4) 28:54
- Lazy Container Views (Part 3) 20:16
- Lazy Container Views (Part 2) 18:50
- Lazy Container Views (Part 1) 16:05
- Bento Layout (Part 4) 10:06
- Bento Layout (Part 3) 27:25
- Bento Layout (Part 2) 13:33
- Bento Layout (Part 1) 13:16
- Environment & Preference Updates 15:30
- Tooltips (Part 2) 00:00
- Tooltips (Part 1) 17:14
- Detecting Visible Cells 17:57
- Debugging Animations 23:16
- Picker Animation (Part 2) 13:59
- Picker Animation (Part 1) 17:06
- Wobble Animation 21:08
- Positioning Badges (Part 2) 17:56
- Positioning Badges (Part 1) 14:10
- Reimplementing the Default Button Style 18:17
- Conditional Aspect Ratio Modifier (Part 2) 17:45
- Conditional Aspect Ratio Modifier (Part 1) 21:20
- Building a Legend View (Part 3) 18:22
- Building a Legend View (Part 2) 28:56
- Building a Legend View (Part 1) 23:34
- Pattern Shape Styles 25:03
- Tweakable Values: Finishing Up 22:35
- Tweakable Values: Custom Editors 16:24
- Tweakable Values: Generics 28:35
- Tweakable Values: Basic Approach 24:13
- Interactive Marquee View (Part 4) 14:25
- Interactive Marquee View (Part 3) 22:54
- Interactive Marquee View (Part 2) 23:17
- Interactive Marquee View (Part 1) 23:08
- Cubic Bezier Keyframes (Part 5) 22:54
- Cubic Bezier Keyframes (Part 4) 19:55
- Cubic Bezier Keyframes (Part 3) 25:17
- Cubic Bézier Keyframes (Part 2) 19:40
- Cubic Bézier Keyframes (Part 1) 22:38
- Building Keyframe Animations (Part 3) 24:36
- Building Keyframe Animations (Part 2) 20:02
- Building Keyframe Animations (Part 1) 23:53
- Swift, the Language: Swift Observation: Observable Macro (Part 2) 11:38
- Swift, the Language: Swift Observation: Observable Macro (Part 1) 27:11
- Swift, the Language: Swift Observation: Calling Observers 17:43
- Swift, the Language: Swift Observation: Access Tracking 22:08
- Connecting Lines with Anchors (Part 3) 24:46
- Connecting Lines with Anchors (Part 2) 20:15
- Connecting Lines with Anchors (Part 1) 16:38
- Reimplementing Anchors: Transforms 21:09
- Reimplementing Anchors: Points 21:09
- Reimplementing Anchors: Bounds 27:47
- Flow Layout Alignment 24:06
- Swift, the Language: Attributed String Builder (Part 6) 17:59
- Swift, the Language: Attributed String Builder (Part 5) 20:41
- Swift, the Language: Attributed String Builder (Part 4) 23:18
- Swift, the Language: Attributed String Builder (Part 3) 16:30
- Swift, the Language: Attributed String Builder (Part 2) 19:30
- Swift, the Language: Attributed String Builder (Part 1) 16:32
- Scroll View with Tabs (Part 2) 24:38
- Scroll View with Tabs 20:24
- Sticky Headers for Scroll Views (Part 2) 20:59
- Sticky Headers for Scroll Views 25:37
- Staggered Animations with Animatable Views 17:42
- Staggered Animations with Variadic Views 17:42
- Staggered Animations 21:54
- Async Image: Cleaning Up 19:36
- Async Image: Caching 14:53
- Async Image: StateObject vs ObservedObject 24:19
- iPhone Simulator Chrome (Part 2) 23:09
- iPhone Simulator Chrome (Part 1) 21:34
- Custom Components: Creating a Custom Stepper 21:11
- Custom Components: Creating a Custom Stepper 29:00
- Custom Components: Making the Stepper Styleable 16:27
- Custom Components: Creating a Custom Stepper 18:02
- Custom Components: Introduction 20:57
- Inspecting HStack Layout 22:48
- Inspecting SwiftUI's Layout Process 18:09
- Search for a Mac App: Jumping to Search Results 24:02
- Search for a Mac App: Generating Search Results 18:56
- Search for a Mac App: Search Field & Completions 19:51
- Building a Photo Grid: Refactoring 23:31
- Building a Photo Grid: Gestures 14:42
- Building a Photo Grid: Spring Animation (Part 1) 29:35
- Building a Photo Grid: Gestures 17:41
- Building a Photo Grid: Animations 20:15
- Building a Photo Grid: Square Grid Cells 20:53
- The Layout Protocol 18:23
- Visualizing Async Algorithms: UI for Combining Algorithms 24:39
- Visualizing Async Algorithms: Combining Algorithms 23:38
- Visualizing Async Algorithms: Supporting More Algorithms 13:46
- Visualizing Async Algorithms: Interactive Inputs 26:28
- Visualizing Async Algorithms: Merging Async Streams 18:05
- Visualizing Async Algorithms: Timeline View 18:05
- Advanced Alignment (Part 3) 20:21
- Advanced Alignment (Part 2) 17:15
- Advanced Alignment (Part 1) 19:16
- Animations and Transactions 17:19
- Large Scrolling Graph (Part 3) 22:29
- Large Scrolling Graph (Part 2) 16:31
- Large Scrolling Graph 21:10
- Matched Geometry Effect (Part 3) 17:12
- Matched Geometry Effect (Part 2) 17:28
- AsyncImage 12:13
- Matched Geometry Effect (Part 1) 23:47
- Gestures and Animations (Part 2) 23:47
- Gestures and Animations 29:42
- Building a MapViewReader 17:46
- Flow Layout Revisited 25:53
- SwiftUI Layout Challenge 3 24:07
- SwiftUI Layout Challenge 2 18:00
- SwiftUI Layout Challenge 1 19:51
- Testing Animations with Previews 25:46
- Designing with Previews 19:34
- SwiftUI Slides: Footers 19:20
- SwiftUI Slides: Customizing Animations 16:54
- SwiftUI Slides: Styling Elements with View Modifiers 15:23
- SwiftUI Slides: Sizing Slides to Fit 18:47
- SwiftUI Slides: Function Builders 18:33
- SwiftUI Slides: Build Steps 26:25
- From MVC to SwiftUI — From Classes to Structs 22:24
- From MVC to SwiftUI — Refactoring Model APIs (Part 2) 21:22
- From MVC to SwiftUI — Refactoring Model APIs 29:01
- From MVC to SwiftUI — Lazy Observable Objects 22:56
- From MVC to SwiftUI — Wrapping UIKit Alerts 26:45
- From MVC to SwiftUI — Reusing the Model (Part 2) 32:35
- From MVC to SwiftUI — Reusing the Model 27:22
- Wrapping Map View 14:41
- SwiftUI Stopwatch App: Scaling Text to Fit 18:50
- SwiftUI Stopwatch App: Analog Clock (Part 2) 23:48
- SwiftUI Stopwatch App: Analog Clock 22:24
- SwiftUI Stopwatch App: Lap Times 21:50
- SwiftUI Stopwatch App: Adding the Data Model 27:27
- SwiftUI Stopwatch App: Self-Sizing Buttons 25:24
- SwiftUI Stopwatch App: Custom Button Styles 14:28
- Building a Shopping Cart: Cleanup & Refactoring 23:09
- Building a Shopping Cart: Drag & Drop (Part 2) 26:08
- Building a Shopping Cart: Drag & Drop (Part 1) 26:14
- Building a Shopping Cart: Transitions with View Modifiers 20:59
- Building a Shopping Cart Animation 26:33
- Animation Curves 23:58
- Building a Shake Animation 27:45
- Reordering with Drag Gestures 29:45
- Building a Collection View (Part 2) 25:32
- Building a Collection View (Part 1) 19:21
- Geometry Effects 25:02
- Animating along Paths 21:18
- Paths and Shapes 16:51
- Login and User Sessions 20:17
- Two-Way Bindings 18:35
- Integrating UIKit Components 31:31
- Lazy Data Loading 17:11
- Passing Data Around 24:16
- The Swift Talk App: First Steps 23:00
- Asynchronous Networking with SwiftUI 15:18
- A First Look at SwiftUI 17:32
SwiftUI State Explained

8 Episodes · 2h49min
- Views and Nodes 28:43
- Observed Objects 14:07
- Tuple Views and View Builders 22:50
- Comparing Views 18:08
- Bindings 22:27
- State Properties 27:44
- State Dependencies 14:53
- State and Bindings 20:19
SwiftUI Layout Explained

14 Episodes · 6h09min
- View Protocols and Shapes 21:06
- Fixed Frames 24:37
- Alignment 21:05
- Overlays & Geometry Readers 28:39
- Flexible Frames 22:05
- Ideal Size and Fixed Size 20:27
- HStack with Fixed Views 25:04
- HStack with Flexible Views 35:11
- Custom Alignment 35:03
- Custom Alignment (Part 2) 35:21
- Layout Priorities 25:59
- Fuzzing HStack 36:07
- Grids with Fixed Columns 19:27
- Grids with Flexible Columns 19:10
SwiftUI Path Builder

9 Episodes · 3h15min
- Detecting Taps 13:13
- Drawing Curves 23:39
- Moving Points 25:58
- More Gestures 26:30
- Generating Code 19:11
- Selection 25:16
- Keyboard Commands 22:50
- Grid Snapping 22:49
- App Lifecycle 16:22
Quick Open

6 Episodes · 2h21min
- Simple Fuzzy Matching 19:00
- Scoring Results 17:53
- Complete Matching 21:42
- From Recursion to Loops 32:19
- Optimizing Performance 32:18
- Optimizing Performance (Part 2) 17:51
Building a Template Language

8 Episodes · 3h02min
- Parsing 31:37
- Parse Errors 20:05
- Evaluation 23:05
- Evaluation Errors 22:11
- Attribute Escaping 22:16
- Parsing For Loops 21:51
- Evaluating For Loops 16:52
- Member Expressions 24:58
Retro Rampage

8 Episodes · 3h01min
- Pushing Pixels 28:14
- Setting the Player in Motion 28:14
- Enter the Maze 22:17
- Collision Handling 26:59
- Line Drawing 16:09
- Ray Casting 20:42
- Drawing in 3D 21:43
- Final Tweaks 17:12
SwiftUI Stopwatch App

7 Episodes · 2h34min
- Custom Button Styles 14:28
- Self-Sizing Buttons 25:24
- Adding the Data Model 27:27
- Lap Times 21:50
- Analog Clock 22:24
- Analog Clock (Part 2) 23:48
- Scaling Text to Fit 18:50
Markdown Playgrounds

7 Episodes · 2h54min
- Setting Up a Document-Based App 25:12
- Markdown Syntax Highlighting 26:27
- Executing Swift Code 23:11
- String Handling 29:47
- Swift Syntax Highlighting 29:41
- Building a Link Checker 19:17
- Improving Performance 21:15
Map Routing

7 Episodes · 2h54min
- Rendering Tracks 19:06
- Selecting Points on Tracks 25:41
- Shortest Distance from Point to Line 26:45
- Building the Graph (Part 1) 31:53
- Building the Graph (Part 2) 18:38
- Performance Optimizations 21:15
- Dijkstra's Shortest Path Algorithm 30:46
Building a Layout Library

8 Episodes · 3h00min
- Introduction & Prototype 31:19
- Spacing & Better Syntax 24:25
- Refactoring for Efficiency & Upcoming Features 24:56
- Flexible Spaces 15:37
- Nested Layouts 23:49
- Margins and Backgrounds 20:11
- Flexible Boxes 19:21
- Building a Responsive Layout 20:44
Building a Form Library

10 Episodes · 4h02min
- Introduction 24:56
- Simplifying IndexPath Logic 21:52
- Extracting a Reusable Form View Controller 20:20
- Creating a Reusable Form Driver 30:29
- Cleaning Up the Code 21:44
- Creating Reusable Components 29:02
- Cell and Section Helpers 27:02
- Declarative Syntax 24:28
- Text Fields, Multi-Select, and Nested Forms 27:45
- Showing & Hiding Sections 14:56
Refactoring Large View Controllers

6 Episodes · 2h36min
- Extracting Pure Functions 26:11
- Extracting Model Code 18:50
- Extracting Networking Code 27:53
- Child View Controllers 26:27
- Child View Controllers (2) 29:52
- Extracting View Code 27:27
Swift, the Language

62 Episodes · 21h59min
- Swift 6 Concurrency (Part 5) 30:03
- Swift 6 Concurrency (Part 4) 23:44
- Swift 6 Concurrency (Part 3) 18:12
- Swift 6 Concurrency (Part 2) 18:24
- Swift 6 Concurrency (Part 1) 22:06
- Structural Programming: Generating Random Values 20:13
- Structural Programming: More Macros 16:07
- Structural Programming: Separating Structure and Values 25:34
- Structural Programming: Enums 37:34
- Structural Programming: Generating Forms 22:33
- Structural Programming: Macros 32:16
- Structural Programming: Introduction 12:49
- Swift Observation: Observable Macro (Part 2) 11:38
- Swift Observation: Observable Macro (Part 1) 27:11
- Swift Observation: Calling Observers 17:43
- Swift Observation: Access Tracking 22:08
- Attributed String Builder (Part 6) 17:59
- Attributed String Builder (Part 5) 20:41
- Attributed String Builder (Part 4) 23:18
- Attributed String Builder (Part 3) 16:30
- Attributed String Builder (Part 2) 19:30
- Attributed String Builder (Part 1) 16:32
- SwiftUI: Visualizing Async Algorithms: UI for Combining Algorithms 24:39
- SwiftUI: Visualizing Async Algorithms: Combining Algorithms 23:38
- SwiftUI: Visualizing Async Algorithms: Supporting More Algorithms 13:46
- SwiftUI: Visualizing Async Algorithms: Interactive Inputs 26:28
- SwiftUI: Visualizing Async Algorithms: Merging Async Streams 18:05
- SwiftUI: Visualizing Async Algorithms: Timeline View 18:05
- AsyncStream & Cancelation 18:44
- Reporting Results with AsyncStream 16:55
- Manual Continuations 18:10
- Concurrent Web Crawler (Part 2) 24:09
- Concurrent Web Crawler 25:30
- Async Delegates 27:20
- Delegates and AsyncStream 27:20
- Structured Concurrency (Part 2) 22:25
- Structured Concurrency (Part 1) 22:35
- Swift Concurrency: Async Streams 19:01
- Swift Concurrency: Async Sequences (Part 3) 24:59
- Swift Concurrency: Async Sequences (Part 2) 20:57
- Swift Concurrency: Async Sequences (Part 1) 23:47
- Parsing with Mutating Methods 33:43
- String Interpolation in Swift 5 (Part 2) 14:57
- String Interpolation in Swift 5 16:47
- Server-Side Swift: Building a Custom XML Decoder (Part 2) 22:19
- Server-Side Swift: Building a Custom XML Decoder 24:46
- Server-Side Swift: Reflection with Mirror and Decodable 23:29
- Handling Optionals 22:44
- Practicing with Pointers 22:22
- Concurrent Map 21:60
- Swift String vs. NSString 13:22
- String Parsing Performance 25:08
- Swift Strings and Substrings 28:29
- Auto Layout with Key Paths 17:25
- Type-Safe File Paths with Phantom Types 24:14
- Deleting Code with Swift 4 11:49
- Combined Class and Protocol Requirements 15:59
- Mutating Untyped Dictionaries 15:14
- Protocols & Class Hierarchies 16:03
- Splitting Arrays 24:07
- Structs and Mutation 16:08
- Understanding Value Type Performance 18:52
Networking

9 Episodes · 3h18min
- Testing Networking Code 24:39
- Combined Resources with Futures 20:08
- Combined Resources (Part 2) 22:10
- Combined Resources (Part 1) 22:44
- Tiny Networking Library Revisited 21:57
- Adding Caching 23:33
- Adding POST Requests 18:41
- Loading View Controllers 21:50
- Tiny Networking Library 22:50
Architecture

20 Episodes · 7h25min
- Refactoring Large View Controllers: Extracting View Code 27:27
- Refactoring Large View Controllers: Child View Controllers (2) 29:52
- Refactoring Large View Controllers: Child View Controllers 26:27
- Refactoring Large View Controllers: Extracting Networking Code 27:53
- Refactoring Large View Controllers: Extracting Model Code 18:50
- Refactoring Large View Controllers: Extracting Pure Functions 26:11
- Sharing State between View Controllers in MVC (Part 2) 24:09
- Sharing State between View Controllers in MVC (Part 1) 19:25
- Introducing Our New Book: App Architecture 04:41
- View Bindings in Pure Swift (Part 2) 21:10
- View Bindings in Pure Swift 22:12
- Adding a Custom View to a View-State Driven App 33:32
- The Elm Architecture (Part 2) 24:60
- The Elm Architecture (Part 1) 16:39
- Testable View Controllers with Reducers 31:01
- UI Elements with Callbacks 16:28
- View Controller Refactoring 16:52
- Delegates & Callbacks 15:29
- Stack Views with Enums 21:43
- Connecting View Controllers 20:15
Functional Programming

18 Episodes · 6h55min
- Making Impossible States Impossible 19:24
- Processing CommonMark using Folds 27:39
- Reduce vs. Fold 23:26
- The Origins of Reduce 23:37
- Server-Side Swift: Functional Dependencies 26:39
- Libraries: Rendering Markdown with Syntax Highlighting 23:44
- Swift, the Language: Concurrent Map 21:60
- Libraries: Extensible Libraries 2: Protocol Composition 23:40
- Libraries: Extensible Libraries 1: Enums vs Classes 22:25
- Type-Safe API Wrappers: Wrapping Analytics APIs 22:44
- Refactoring Imperative Layout Code 18:41
- Data Structures: Red-Black Trees 31:51
- Data Structures: Binary Search Trees 27:00
- From Runtime Programming to Functions 23:06
- Ledger Mac App: Building Parser Combinators (Part 2) 21:31
- Ledger Mac App: Building Parser Combinators (Part 1) 16:22
- Rendering CommonMark (Part 2) 18:34
- Rendering CommonMark 23:16
Table Views

4 Episodes · 1h29min
- Table View Animations with Reactive Arrays 15:27
- Driving Table View Animations 30:24
- Generic Table View Controllers (Part 2) 23:30
- Generic Table View Controllers 19:42
Reactive Programming

12 Episodes · 4h57min
- Incremental Programming: Reference Cycles and Ownership 35:48
- Incremental Programming: A Technique to Avoid Reactive Glitches 24:56
- Incremental Programming: Understanding Reactive Glitches 18:16
- Table Views: Table View Animations with Reactive Arrays 15:27
- Experiments: Reactive Data Structures: Arrays 30:55
- Experiments: Reactive Data Structures: Linked Lists 25:58
- iOS at Kickstarter: Test-Driven Reactive Programming 38:47
- Thread Safety 23:36
- Signal Ownership and Subscriptions 16:29
- From Futures to Signals 23:46
- Futures 17:30
- Reactive Programming 26:12
Incremental Programming

3 Episodes · 1h18min
- Understanding Reactive Glitches 18:16
- A Technique to Avoid Reactive Glitches 24:56
- Reference Cycles and Ownership 35:48
Server-Side Swift

21 Episodes · 7h57min
- Routing with Codable – Decoding 19:02
- Routing with Codable – Encoding 19:46
- SwiftUI-Style Backend Library – Rule Modifiers 19:58
- SwiftUI-Style Backend Library – Async Await 20:12
- SwiftUI-Style Backend Library – Environment 25:39
- SwiftUI-Style Backend Library – Paths 26:37
- SwiftUI-Style Backend Library 25:57
- Swift, the Language: String Interpolation in Swift 5 (Part 2) 14:57
- Swift, the Language: String Interpolation in Swift 5 16:47
- Flow Testing with Protocols 18:11
- Functional Dependencies 26:39
- The Swift Talk Backend (Part 3) 20:59
- The Swift Talk Backend (Part 2) 25:40
- The Swift Talk Backend (Part 1) 25:20
- Building a Custom XML Decoder (Part 2) 22:19
- Building a Custom XML Decoder 24:46
- Reflection with Mirror and Decodable 23:29
- Interfacing with PostgreSQL (Part 2) 25:15
- Interfacing with PostgreSQL 28:50
- Routing 22:48
- Setting Up a Server-Side Swift Project 24:33
Type-Safe API Wrappers

6 Episodes · 2h13min
- Wrapping libgit2 33:31
- Wrapping Analytics APIs 22:44
- Typed Notifications (Part 2) 18:02
- Typed Notifications (Part 1) 17:53
- Networking: Adding POST Requests 18:41
- Networking: Tiny Networking Library 22:50
Libraries

5 Episodes · 1h55min
- Rendering Markdown with Syntax Highlighting 23:44
- Extensible Libraries 2: Protocol Composition 23:40
- Extensible Libraries 1: Enums vs Classes 22:25
- Type-Safe API Wrappers: Wrapping Analytics APIs 22:44
- Networking: Tiny Networking Library 22:50
Tooling

6 Episodes · 2h13min
- iOS Remote Debugger: The Network Framework 25:59
- iOS Remote Debugger: Receiving Data 29:35
- iOS Remote Debugger: Sending Data 22:38
- iOS Remote Debugger: Connecting with Bonjour 28:31
- Xcode 9 Productivity Tips 14:25
- Refactoring with Xcode 9 12:35
iOS at Kickstarter

4 Episodes · 2h01min
- View Models 33:58
- Deep Linking 27:12
- Playground-Driven Development 21:24
- Test-Driven Reactive Programming 38:47
Collection Protocols

6 Episodes · 1h38min
- Conforming IndexSet to Collection 16:52
- Conforming IndexSet to Sequence 14:09
- Building a Custom IndexSet Collection 18:52
- Sorted Arrays 16:42
- Sequence & Iterator 16:54
- Array, ArraySlice & Collection 15:17
Data Structures

4 Episodes · 1h53min
- Playground QuickLook for Binary Trees 27:58
- Red-Black Trees 31:51
- Binary Search Trees 27:00
- Sorted Arrays with Binary Search 26:51
Experiments

40 Episodes · 15h47min
- Pretty Printing: Annotations 16:33
- Pretty Printing: Indentation 18:10
- Pretty Printing: Choices 16:05
- Pretty Printing: Data Structure 18:51
- Swift, the Language: Structural Programming: Generating Random Values 20:13
- Swift, the Language: Structural Programming: More Macros 16:07
- Swift, the Language: Structural Programming: Separating Structure and Values 25:34
- Swift, the Language: Structural Programming: Enums 37:34
- Swift, the Language: Structural Programming: Generating Forms 22:33
- Swift, the Language: Structural Programming: Macros 32:16
- Swift, the Language: Structural Programming: Introduction 12:49
- Git Under the Hood: Writing Trees & Commits 16:06
- Git Under the Hood: Writing Blobs 19:02
- Git Under the Hood: Commits 24:03
- Git Under the Hood: Trees 21:32
- Git Under the Hood: Blobs 26:10
- CRDTs – Collection Conformance 30:24
- CRDTs – Deletion in Sequences 15:34
- CRDTs – Array-Based Sequences 32:57
- CRDTs – Merging Sequences 20:52
- CRDTs – Sequences 25:23
- CRDTs – Testing & Integration 20:02
- CRDTs – Grow-Only Counter 24:10
- CRDTs – Introduction 24:20
- Static Site Generator: Environment Property Wrapper 20:42
- Static Site Generator: ForEach and Templates 20:42
- Static Site Generator: Result Builders 13:54
- Static Site Generator: The Environment 21:38
- Static Site Generator: Defining Rules 12:52
- Drawing Trees (Part 2) 21:29
- Drawing Trees (Part 1) 21:50
- A Parser Using SIMD and Bitwise Operations (Part 2) 33:55
- A Parser Using SIMD and Bitwise Operations (Part 1) 40:57
- 100th Episode Live Q&A 48:41
- Architecture: View Bindings in Pure Swift (Part 2) 21:10
- Architecture: View Bindings in Pure Swift 22:12
- Reactive Data Structures: Arrays 30:55
- Reactive Data Structures: Linked Lists 25:58
- Mutable Shared Structs (Part 2) 22:60
- Mutable Shared Structs (Part 1) 30:10
Ledger Mac App

9 Episodes · 3h09min
- Introduction 07:45
- Evaluating Expressions 29:36
- Evaluating Transactions 25:43
- Parsing Techniques 25:24
- Growing Trees with Classes and Structs 28:11
- Building Parser Combinators (Part 1) 16:22
- Building Parser Combinators (Part 2) 21:31
- Architecture 18:32
- Adding Search 16:00