How SwiftUI’s AnyView type can often be avoided, and why it might be a good idea to do so.

How to validate email addresses in Swift using a dedicated RawRepresentable type and Foundation’s NSDataDetector API.

How URLSession can be used to perform POST requests and file uploads without any third party libraries.

How key paths can be made much more powerful when used to query and filter collections.

How a SwiftUI view’s body can be split up into multiple computed properties, which is a great alternative to using separate types in certain situations.

Wrapping up the weekly article series with three of my major overall learnings after close to four years of continuous writing about Swift.

A look at what it means for SwiftUI to be a value-driven UI framework, and how we might need to break certain assumptions when adopting SwiftUI within our projects.

A look at the various sorting APIs that the Swift standard library offers, and how we could augment those APIs in order to make more advanced sorting tasks easier to perform.

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.

In this second article about integrating SwiftUI and UIKit, we’ll take a look at how SwiftUI views can be embedded within UIKit-based view controllers, and various ways of sharing state between them.

A closer look at how SwiftUI and UIKit can be combined in various ways, starting with how we can bring increasingly complex UIKit-based views and view controllers into the declarative world of SwiftUI.

Formatting numbers into human-readable strings can often be tricker than expected. Let’s explore why that is, and what kind of tools and techniques that can be good to keep in mind when formatting different kinds of numbers.

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.

An overview of the sort of patterns and techniques that Swift’s extensions enable us to adopt, and how extensions can turn out to be one of the most powerful features that the language has to offer.

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.