Creating Combine-compatible versions of async/await-based APIs
Creating convenience APIs that make it possible to convert async/await-based functions into Combine publishers.
Articles, podcasts and news about Swift development, by John Sundell.
Articles, podcasts and news about Swift development, by John Sundell.
Creating convenience APIs that make it possible to convert async/await-based functions into Combine publishers.
Ben Scheirman returns to the show to talk about modern UIKit-based app development, how UIKit has evolved over the past few years, and how its API design and usage has been influenced by the introduction of frameworks like SwiftUI and Combine.
How the share operator enables a Combine publisher to be reused without requiring duplicate work to be performed for each subscriber.
How Swift’s AsyncSequence and AsyncStream APIs can be used to build asynchronous sequences, and how they relate to Apple’s Combine framework.
Let’s explore how we can make it possible to call async/await-powered APIs within a Combine pipeline.
How to implement timing features like debouncing, deferring, and delayed retries when building Combine-based data pipelines.
How Combine’s Future and subject types enable us to build many different kinds of functionality without having to write custom publisher implementations from scratch.
Donny Wals, book author and iOS developer at Disney Streaming Services, joins John to give practical tips on Combine and Core Data. How to manage and test increasingly complex Combine pipelines, and how come the opinions on Core Data are so divisive? Also, working on internal SDKs and frameworks, and taking a pragmatic approach to unit testing.
How to unit test code that’s based on Combine publishers, and how Combine’s built-in API can be augmented with test-specific utilities.
How to avoid common memory-related issues when working with self and cancellable references within the context of Combine.
Matt Gallagher, creator of Cocoa with Love, returns to the show to discuss how the introduction of SwiftUI and Combine has impacted how apps are architected on Apple’s platforms, and what sort of principles that are good to keep in mind when designing a solid app architecture.
How URLSession can be used to perform POST requests and file uploads without any third party libraries.
How custom Combine operators and convenience APIs can be implemented using extensions, and how doing so can let us eliminate common sources of boilerplate when implementing things like networking and data validation.
Daniel Steinberg joins John to discuss how various functional programming patterns can be adopted in Swift, and how many of those patterns can be found in both the standard library and in frameworks like Combine and SwiftUI.
How Combine’s operators for connecting and merging publishers can be used to solve real-world problems, such as nested network calls, handling multiple input sources, and more.
A few different patterns and approaches that can be used to handle and render asynchronous loading states within SwiftUI-based views.
How networking code can be tested without needing to introduce complex abstractions within our production code, by using system-provided APIs for overriding and mocking various kinds of requests.
A few different techniques that can help us share common networking logic, while also utilizing Swift’s advanced type system to make that kind of code more robust.
This week, let’s take a look at what goes into building a custom Combine publisher, and what sort of situations that might require us to do that.
A look at a few somewhat lesser-known ways in which enums can be used to solve various problems in Swift-based apps and libraries.
Let’s take a look at a few key APIs and techniques that can be really useful when building custom developer tools, scripts, or other kinds of automation, in Swift.
A summary of all Swift by Sundell content published during April 2020.
Combine is a really powerful reactive programming framework from Apple, but getting started with it can be quite difficult, so let’s go through the basics of its API and its core concepts.
This week, let’s explore the topic of published properties, by reimplementing Combine’s @Published property wrapper with support for earlier versions of Apple’s operating systems.
This week, let’s take a look at a few different ways that reducers can be used in Swift — ranging from transforming sequences, to accumulating asynchronous values using Apple’s new Combine framework, and beyond.
Marin Todorov joins John to talk about bridging the gap between UIKit, Combine and SwiftUI, how to design intuitive and robust APIs, and how the developer community can augment Apple’s SDKs through open source.
Casey Liss joins John to talk about Apple’s newly announced Combine framework for reactive programming, how it compares to existing tools like RxSwift, and different strategies for adopting it. Also, unit testing, life as an indie developer, and much more.