iOS Newsletter
Hi folks,
This week we’re diving into some advanced Swift language features - constructing generics at runtime, new concurrency improvements in Swift 6.1, and we’re exploring a new protocol that is meant to unify the way we communicate with AI/ML models.
Enjoy!
Swift
New Concurrency Stuff with Swift 6.1
It’s been a while since Apple released the first beta release of Swift 6.1. As further Concurrency improvements are still on the drawing board, this article takes a look at what’s new with this beta.
Swift’s approach to SPI
Most, if not all, Swift developers are familiar with Swift’s access control system. It enables us to hide the implementation details of our code and design a clean interface (the so-called API) through which the code can be accessed. While this system is pretty powerful, we unfortunately hit its limits if we want to custom-tailor our API for different use cases — such as broadening the number of exposed interfaces for internal products while keeping a more refined public API for third-party consumers. Luckily, there’s a solution — the experimental @_spi attribute — which gets explored in more detail in this article.
Advanced Swift: Fatal Error
fatalError() is a very special language construct that means your app has reached a point where continuing execution no longer makes sense. This could be due to a programming mistake, an unexpected missing resource, or an invalid state that the app was not prepared to handle. These are not like the other errors that Swift allows you to handle gracefully, so check the article for some good practices around it.
Preventing Accidental API Breaks: A Swift Developer’s Guide to API Diffing
Ask any SDK developer and they will tell you that evolving our APIs and maintaining stability can be quite challenging. It’s fairly easy to break our clients’ applications if we’re not careful - for example, by simply removing a parameter or changing a method signature. While Swift has a robust type system that helps us catch many issues at compile-time, detecting API-breaking changes before they reach production requires specialized tooling. This article goes through the options that we have at hand.
Dynamically Constructing Generic Types in Swift
Swift’s type system is powerful but sometimes challenging, especially when dealing with generic types at runtime. This article explores how to dynamically construct generic types in Swift - a technique that’s particularly useful for framework developers and those working with advanced Swift patterns.
UI/UX
How to create a Conditional View Modifier in SwiftUI
There are many ways we can benefit from using view modifiers. This article shows us how to build a modifier that only gets applied when a certain condition is met. Useful for tidying up the version/platform checks in our SwiftUI views.
Creating App Intents using Assistant Schemas
App Intents is an area that Apple has been focusing on for quite some time. With the goal of improving voice communication, some of the changes around intents impact design choices concerning development: if the device must be able to perform any kind of action for the user, the regulation behind choosing which actions to expose to the system moves from exposing only the most important ones to implementing an intent for all the possible actions of an app by default. Apple Intelligence models are trained on and expect specific patterns to start processing and reasoning over the voice requests prompted by the user. To support this new approach and create a system that guarantees and simplifies intent development, Apple introduced a series of schema protocols grouped around content-related domains - read on to discover more.
AI/ML
Model Context Protocol (MCP)
Patterns usually arise when there’s a variety of offerings and plenty of demand. AI is in that state, and it seems that’s why there’s the Model Context Protocol (MCP) - an effort to unify the way we communicate with models. This article is a bit of everything - an intro, a technical walkthrough, and a link to a public GitHub repo containing a macOS application that uses MCP to communicate with Claude Desktop so that you can feed the service with context that’s relevant to you. Interesting even from the scope of “how to”.