Short on time this week? Here's the TL;DR: Swift now works in basically every AI-native IDE, Xcode 26.4 has a really annoying paste bug with a simple workaround, the April 28 SDK deadline is this month, and a Swift-native game engine just dropped a proper release. Oh, and Deep Dish Swift wrapped up in Chicago a few days ago. Let's get into it. 🚀

Swift Is Now in (Almost) Every IDE

As of April 8th, the official Swift extension for VS Code is now available on the Open VSX Registry, the vendor-neutral, open source extension registry hosted by the Eclipse Foundation. That means you can now write Swift in Cursor, VSCodium, AWS's Kiro, Google's Antigravity, and more, all without a manual download. Swift

The extension brings code completion, refactoring, full debugging support, a test explorer, and DocC support to the entire ecosystem of VS Code-compatible editors. Agentic IDEs like Cursor and Antigravity can now automatically install Swift support when they detect a Swift project. InfoWorld

The bigger picture here is what iOS Dev Weekly's Dave Verwer put well this week: Swift is bigger than Xcode now. Android, Wasm, Windows, embedded hardware, and now every major AI IDE, the language has quietly become general-purpose in a way that would have seemed unlikely five years ago.

Expanding Swift’s IDE Support

You can now write Swift in a broader range of popular IDEs, including Cursor, VSCodium, AWS’s Kiro, and Google’s Antigravity. By leveraging VS Code extension compatibility, these editors tap directly into the Open VSX Registry, where the official Swift extension is now live.

Swift.orgApple Inc.

PSA: Xcode 26.4 Broke Simulator Paste

After updating to Xcode 26.4, pasting from your Mac into the iOS Simulator is completely broken. Cmd+V does nothing, long-pressing a text field shows no Paste option, and the Simulator's clipboard appears empty. Restarting the Simulator, toggling "Automatically Sync Pasteboard," and resetting privacy settings all fail to fix it. @samwize

The workaround, courtesy of Junda Ong:

bash

echo -n "your text here" | xcrun simctl pbcopy booted

This bypasses the broken Mac-to-Simulator auto-sync by writing directly to the Simulator's pasteboard. You still need to Cmd+V inside the Simulator after running it, but it works. @samwize

If running that command manually every time sounds tedious — it is. Junda followed up by vibe coding a small Mac app that keeps the two clipboards in sync automatically, using the one-liner pbpaste | xcrun simctl pbcopy booted under the hood. @samwize Apple has acknowledged the bug and is working on a fix; Xcode 26.5 Beta is reportedly where to watch for the resolution.

Workaround post · The vibe-coded fix · Apple Developer Forums thread

⚠️ SDK Deadline: April 28 — Two Weeks Away

You've seen this before, but it's worth repeating since it's now genuinely urgent. Starting April 28, 2026, all apps and games uploaded to App Store Connect must be built with the iOS 26 & iPadOS 26 SDK or later. The same applies to tvOS 26, visionOS 26, and watchOS 26. Apple Developer

If you haven't migrated to Xcode 26 yet, now is the time. The watchOS requirement also specifically mandates 64-bit support for Apple Watch Series 9, Series 10, and Apple Watch Ultra 2. Don't wait until April 27th.

Latest News - Apple Developer

Learn about the latest technologies, events, and policies for developers.

Apple Developer

Untold Engine Studio: A Swift Game Engine Worth Watching

Harold Serrano released Untold Engine Studio this week, the first bundled desktop release of the Untold Engine ecosystem. The goal is to remove friction: download a .dmg, and start building games immediately without cloning repos or setting up dependencies. Harold Serrano

The engine is written in Swift and powered by Metal, supporting macOS, iOS, and visionOS. It uses an ECS-based gameplay model and includes Gaussian Splat Rendering that runs natively on Vision Pro hardware.

untoldengine - Overview

An easy to use, open source, 3D game engine for iOS/macOS game development. - untoldengine

GitHub

It's code-driven rather than editor-first, so it's aimed at developers who want to understand and shape the underlying system.

Not trying to dethrone Unreal or Unity, just a well-crafted, native, Swift-first option that's been in development for over 12 years and is finally at a polished release point.

Blog - Harold Serrano | Game Engine Developer

Interested in making a game engine from scratch? In these articles I share everything you need to know about game engine development.

Harold SerranoHarold Serrano

Deep Dish Swift 2026 Wrapped Up This Weekend

Deep Dish Swift hosted its fourth conference in Chicago this weekend, April 12–14, bringing together developers of all experience levels to share knowledge from a diverse set of speakers. Deepdishswift Sessions will be published after the conference, so keep an eye on their YouTube channel if you missed it. A solid lineup this year, look out for the talks on indie development, structured concurrency, and Server-Side Swift.

Deep Dish Swift 2026 | April 12th to 14th

A supreme Swift developer conference being served in Chicago, Illinois

April 12th to 14th

WWDC 2026: June 8–12, Mark Your Calendar

WWDC 2026 runs June 8–12. Apple will hold it primarily online, with select developers and students invited to Apple Park. 50 Distinguished Swift Student Challenge winners have been invited for a three-day experience in Cupertino, including the keynote on June 8. MacRumors This year, Apple has been teasing AI advancements as a central theme, expect iOS 27 and what comes next for the Foundation Models framework front and center.

Apple’s Worldwide Developers Conference returns the week of June 8

Apple today announced it will host its annual Worldwide Developers Conference (WWDC) online from June 8-12.

Apple Newsroom

✌️ That's Issue #77! Big two weeks: Swift is everywhere now, fix your paste bug before it drives you crazy, and don't miss the April 28 deadline.

Let's get ready for WWDC season to kick into gear! 🚀

What a time to be a Swift developer. Seriously.

Swift 6.3 dropped and it's packed, the official Android SDK is here, Swift Testing keeps leveling up, and the @c attribute finally makes C interoperability feel like a first-class citizen. Oh, and if you've been sleeping on the agentic coding features in Xcode 26.3, we're covering that too because it's genuinely worth your time.

We've also got a deadline reminder that you really don't want to miss (April 28 is closer than it feels), and a shoutout to this year's Swift Student Challenge winners who, as always, have shipped some seriously creative work.

Alright, let's get into it. 🚀

Swift 6.3: Swift Testing Gets Smarter

Swift 6.3 (released March 24) brings three handy improvements to Swift Testing. First, warning issues let you record a non-fatal issue without failing the test:

Issue.record("Something suspicious happened", severity: .warning)

Second, test cancellation lets you bail out mid-test gracefully — useful for skipping specific arguments in a parameterized test, or responding to conditions that make continuing pointless:

try Test.cancel()

And third, image attachments let you attach UIImage, CGImage, CIImage, or NSImage instances directly to your test reports for visual verification — especially handy for snapshot tests or Vision framework work. These are exposed via new cross-import overlay modules with UIKit and friends.

Swift 6.3 Released

Swift is designed to be the language you reach for at every layer of the software stack. Whether you’re building embedded firmware, internet-scale services, or full-featured mobile apps, Swift delivers strong safety guarantees, performance control when you need it, and expressive language features and APIs.

Swift.orgApple Inc.

Swift 6.3: Swift Goes Android

The headline feature of Swift 6.3: the first official Swift SDK for Android. With it you can write native Android apps in Swift, update existing Swift packages to support Android builds, and use Swift Java and Swift Java JNI Core to slot Swift code into apps already written in Kotlin or Java.

// Swift code callable from an Android Kotlin app via Swift Java JNI Core
@_silgen_name("Java_com_example_MyApp_greet")
public func greet() -> String {
    return "Hello from Swift on Android!"
}

This doesn't mean Kotlin is going anywhere, it remains the primary language for Android development. But for teams already deep in Swift for iOS, this opens a path to sharing business logic across platforms without a rewrite.

Swift.org

Swift is a general-purpose programming language built using a modern approach to safety, performance, and software design patterns.

Swift.orgApple Inc.

Swift 6.3: The @c Attribute

Swift 6.3 also formalizes the long-unofficial @_cdecl attribute into the new @c attribute, letting you expose Swift functions and enums directly to C code:

@c public func MyLib_initialize() {
    // Swift implementation, callable from C
}

When combined with @implementation, the compiler will validate that your Swift function's signature matches a pre-existing declaration in a C header — catching mismatches at compile time rather than surfacing them as cryptic "deserialization" failures at runtime.

Embedded Swift Improvements Coming in Swift 6.3

Embedded Swift is a subset of Swift that’s designed for low resource usage, making it capable of running on constrained environments like microcontrollers. Using a special compilation mode, Embedded Swift produces significantly smaller binaries than regular Swift. While a subset of the full language, the vast majority of the Swift language works exactly the same in Embedded Swift. Additional information is described in the Embedded Swift vision document.

Swift.orgApple Inc.

Xcode 26.3: Agentic Coding

If you haven't tried it yet, Xcode 26.3 shipped in late February and introduced agentic coding with Claude Agent and OpenAI Codex baked in. Rather than just suggesting completions, agents can now reason across your whole project: exploring file structures, updating settings, running builds, capturing Xcode Previews to verify UI, and iterating until tests pass.

You stay in control, the agent logs everything in a transcript, automatic milestones let you roll back any change without touching Git, and you can swap between agents mid-project depending on the task.

Any MCP-compatible agent can also plug in via the open Model Context Protocol, it's not just Claude and Codex.

Xcode 26.3 unlocks the power of agentic coding

Xcode 26.3 introduces support for agentic coding, a new way in Xcode for developers to build apps, powered by coding agents from Anthropic and OpenAI.

Apple Newsroom

SDK Deadline: April 28

Reminder, since it's coming up fast. Starting April 28, 2026, apps and games uploaded to App Store Connect need to be built with the iOS 26 & iPadOS 26 SDK or later Apple Developer — same applies to tvOS, visionOS, and watchOS. If you haven't migrated to Xcode 26 yet, that clock is ticking.

Upcoming SDK minimum requirements - Latest News - Apple Developer

Starting April 28, 2026, apps and games uploaded to App Store Connect need to meet the following minimum requirements: iOS and iPadOS apps must be built with the iOS 26 & iPadOS 26 SDK or later tvOS apps must be built with the tvOS 26 SDK or later visionOS apps must be built with the visionOS 26 SDK or later watchOS apps must be built with the watchOS 26 SDK or later Learn more about submitting

Apple Developer

Swift Student Challenge 2026 Winners

Apple began notifying students who won the WWDC 2026 Swift Student Challenge this week. MacRumors Winners receive AirPods Max 2, a one-year Apple Developer membership, and a certificate. 50 Distinguished Winners will be invited to Apple Park for a three-day experience including the WWDC Special Event keynote on June 8. MacRumors

Worth browsing the winners' submissions, they're always a great source of creative SwiftUI and Swift Playgrounds ideas.

Swift Student Challenge

Showcase your love of coding by submitting your app playground to the Swift Student Challenge.

Apple Developer

✌️ That's a wrap for Issue #76! Big month for Swift, a new language version, the Android SDK landing officially, and agentic coding now stable in Xcode. Lots to explore.

As always, reply with what you want covered next. See you in two weeks! 🚀

It's been a little while, hasn't it? First things first, a huge thank you to Marina for everything she's built here. She set an incredible foundation and this community is better for it. Big shoes to fill, but we're going to give it a shot.

I'm Sam, and I'll be taking the reins going forward. I've been a software engineer for 12+ years, 7 of those in the mobile space! I'm genuinely excited to be here. The plan is simple: keep delivering the good stuff, dig a little deeper on the topics that matter to you as iOS devs, and hopefully add a bit more value along the way.

This newsletter is for you, not me. So if there's something you want covered, a topic you've been nerding out on, or even just feedback on how we're doing, please reach out. Seriously. Reply to this email, find me online, whatever works. I want to hear from you.

Alright, enough from me, let's get into it. Since it's been a while, this edition covers more than just the past week. We've pulled together some of the most important updates from the last few months that you'll actually want to know about. Think of it as a catch-up pack. Let's go! 🚀

Foundation Models: Tool Calling

The on-device model in the Foundation Models framework can do more than just generate text, you can give it tools that call back into your app when it needs real-time information. Define a Tool conformance and let the model decide when to invoke it:

struct FlightStatusTool: Tool {
    let name = "FlightStatus"
    let description = "Returns the live status of a flight by number"

    func call(arguments: Arguments) async throws -> ToolOutput {
        let status = await FlightAPI.fetch(flightNumber: arguments.flightNumber)
        return ToolOutput(status)
    }
}

let session = LanguageModelSession(tools: [FlightStatusTool()])
let response = try await session.respond(to: "What's the status of flight UA101?")

This is the key to building agentic features, apps that don't just respond to text, but actively perform actions on the user's behalf.

Deep Dive: The Foundation Models Framework in iOS 26 — On-Device AI That Respects Privacy

Apple’s commitment to “Privacy by Design” has always been its north star, but with iOS 26 and the new Foundation Models Framework (FMF)…

MediumMobile Engineering: Build, Lead, Deliver

In the iOS 26.4 update, the Foundation Models framework got improvements to instruction-following and tool-calling abilities. Since the model changes when a person updates their device, you'll want to re-test your prompts with the new model to verify your app's behavior. Apple Developer Worth doing before your next release.

Foundation Models | Apple Developer Documentation

Perform tasks with the on-device model that specializes in language understanding, structured output, and tool calling.

Apple Developer Documentation

Apple’s Foundation Models framework unlocks new intelligent app experiences

Developers around the world are able to bring even more intelligent experiences into their apps by tapping into Apple’s Foundation Models framework.

Apple Newsroom

Foundation Models Framework Docs · Apple's Foundation Models in Practice

Swift 6.2: Default Actor Isolation

If you've been drowning in @MainActor annotations ever since enabling Swift 6's strict concurrency checking, Swift 6.2 has a direct answer. Default Actor Isolation is a new Swift compiler setting that alters the default behavior of concurrency isolation, instead of assuming no isolation, it now assumes your code should run on @MainActor unless you say otherwise.

Default Actor Isolation in Swift 6.2

Use Default Actor Isolation in Swift 6.2 to run code on the @MainActor by default and smoothen your migration.

SwiftLeeAntoine van der Lee

Enable it in your Package.swift:

swiftSettings: [
    .defaultIsolation(MainActor.self)
]

When you need to introduce actual concurrency, opt in with the new @concurrent attribute. Swift This gives you a clean mental model: single-threaded by default, concurrent by explicit choice.

In Xcode 26, newly created projects have this option enabled and set to MainActor by default. Fatbobman's Swift Weekly For existing projects, the migration tooling can help you update incrementally, don't just flip the flag globally, as it can silently change the behavior of nonisolated async functions.

Should you opt-in to Swift 6.2’s Main Actor isolation? – Donny Wals

Swift 6.2 comes with some interesting Concurrency improvements. One of the most notable changes is that there’s now a compiler flag that will, by default, isolate all your (implicitly nonisolated)…

Donny Walsdonnywals

Swift 6.2: Observations: Transactional State Updates

Swift 6.2 enables streaming transactional state changes of observable types using the new Observations async sequence type. Updates include all synchronous changes to observable properties, and the transaction ends at the next await that suspends, avoiding redundant UI updates, improving performance, and ensuring your code reacts to a consistent snapshot of the value. Swift

Swift 6.2 Released

We’re excited to announce Swift 6.2, a release aimed at making every Swift developer more productive, regardless of where or how you write code. From improved tooling and libraries to enhancements in concurrency and performance, Swift 6.2 delivers a broad set of features designed for real-world development at every layer of the software stack.

Swift.orgApple Inc.

A subtle but impactful improvement if you've ever had views flickering from multiple rapid state changes.

Swift 6.2: Exit Testing in Swift Testing

Swift Testing keeps getting better. Exit testing in Swift 6.2 lets you verify that code terminates under specific conditions, such as a failed precondition. Swift Particularly useful for testing defensive guards that should trigger a fatal error:

@Test func verifyPrecondition() async {
    await #expect(exitsWith: .failure) {
        guard someCondition else { preconditionFailure("Should not reach here") }
    }
}

Swift in the Browser with WebAssembly

One of the standout talks from the Pre-FOSDEM Swift event this year: Simon Leeb demonstrated how to run Swift applications natively in the browser with WebAssembly, using ElementaryUI. Swift The full YouTube playlist from the pre-conference event is worth a browse, talks cover embedded Swift, server-side Swift, Android, and more.

Swift System Metrics 1.0

The 1.0 release of Swift System Metrics makes it easy to collect process-level metrics like CPU utilization time and memory usage, running on both Linux and macOS with a common API across platforms. Swift Handy for any server-side Swift work or for profiling long-running background processes.

Announcing Swift System Metrics 1.0: Process-Level Monitoring

We are excited to announce the 1.0 release of Swift System Metrics, a Swift package that collects process-level system metrics like CPU utilization time and memory usage. Swift System Metrics runs on both Linux and macOS, providing a common API across platforms.

Swift.orgApple Inc.

SDK Requirement Deadline

Mark your calendar. Starting April 28, 2026, apps and games uploaded to App Store Connect must be built with the iOS 26 & iPadOS 26 SDK or later. Apple Developer If you haven't migrated your project to Xcode 26 yet, now is the time.

Upcoming SDK minimum requirements - Latest News - Apple Developer

Starting April 28, 2026, apps and games uploaded to App Store Connect need to meet the following minimum requirements: iOS and iPadOS apps must be built with the iOS 26 & iPadOS 26 SDK or later tvOS apps must be built with the tvOS 26 SDK or later visionOS apps must be built with the visionOS 26 SDK or later watchOS apps must be built with the watchOS 26 SDK or later Learn more about submitting

Apple Developer

Design System & Liquid Glass

If you're building or scaling a design system, John Sundell has a timely piece on the topic over at Swift by Sundell. A design system will probably never be "finished", it needs to continuously evolve to adapt to new designs and system changes from Apple, like the introduction of Liquid Glass in iOS 26. Swift by Sundell Worth reading if your component library is starting to groan under the weight of custom UI work.

Building a design system at Genius Scan | Swift by Sundell

An example of how to approach the task of building a design system for an app, by focusing on creating an initial set of reusable components that can be tweaked using the SwiftUI environment.

Swift by Sundell

✌️ That's it for now! Stay curious, ship thoughtfully, and test your prompts with every OS update.

Xcode and ChatGPT Support

Hot news right now is the announcement of a direct integration between ChatGPT and Xcode (requires ChatGPT subscription).

This means less cut and paste. You can assume it will understand the file context of your question, you can highlight incorrect lines when asking it to make corrections, and you can  ask it to summarize a file. 

To use it, toggle on "Enable Works with Apps" in ChatGPT settings and then select this icon on the ChatGPT bar:

And yes – this does give ChatGPT much deeper access into your code (all open windows) – and you should consider the personal and legal aspects of that. Although 'temporary chat' modes are available, it is nonetheless something that your employer might have an opinion on. 

Xcode + ChatGPT: Official Support is Available Now

Free read for non-members: https://medium.com/@hiandic/dc21998f3653?source=friends_link&sk=e4dfbadcc5281bd474ecd546b221877e

Simpra TechHalil İbrahim Andiç

ChatGPT + XCode

Video’s delen met vrienden, familie en de rest van de wereld

YouTube

Swift Testing: Parameters

If you want to run a single test for a range of different parameters, inject them into the test as an argument with @Test(arguments:). You can inject an array, several arrays, or even zipped arrays - for when the test parameters come in pairs. For example:

@Test(arguments: zip([18, 30, 50, 70], [77.0, 73, 65, 61]))
  func verifyNormalHeartRate(age: Int, bpm: Double) {
    let hr = HeartRate(bpm: bpm)
    let context = HeartRateContext(age: age, activity: .regular, heartRate: hr)
    #expect(context.zone == .normal)
}

If there is a failure, then the Test Navigator will highlight exactly which parameter values are responsible. 

Introducing Swift Testing. Parameterized Tests.

I decided to finalize the topic of the Swift Testing framework with its unique feature called parameterized tests. In a few cases, you need to verify your functions with different inputs, and parameterized tests easily solve this by providing you with a nice overview.

Swift with MajidMajid Jabrayilov

Swift Testing: Traits & Tags

Trait annotation are used to conditionally skip tests based on a feature flag:

// Conditionally skip tests based on a feature flag
@Test(
    .enabled(if: FeatureFlag.addition),
    .enabled(if: FeatureFlag.anotherFlag)
)

Using tags (that you define yourself) lets you run tests by tag and visualize if all the tests in the tag pass:

// Group tests with a custom tag
@Test(.tags(.crucial, .checkout))

extension Tag {
    @Tag static var crucial: Self

Introducing Swift Testing. Traits.

The most powerful feature of the Swift Testing framework is the trait system. Traits allow us to annotate a test or test suite to customize its behavior. This week, we will learn how to use built-in trait types to modify tests.

Swift with MajidMajid Jabrayilov

Swift Testing: Suites

Or why not group your tests using the Suite macro applied to your test class:

// Name your Suite 
@Suite("Serial model tests") 

// Timeout your Suite
@Suite(.timeLimit(.minutes(1)))

// Serialize your Suite
@Suite(.serialized)

Introducing Swift Testing. Lifecycle.

Any function marked with the @Test macro can be a test in the world of the Swift Testing framework. But how do you handle the lifecycle of the tests? How do you define test suites and provide setup and teardown functionality? This week, we will learn how to handle the test lifecycle in Swift Testing framework.

Swift with MajidMajid Jabrayilov

Swift Testing: Require Macro

Let's increase the clarity of your tests by choosing #require to differentiate test pre-requisites from the feature actually being tested.

try #require(person != nil, "Person should exist")

For more examples using #require vs #expect, see SwiftLee and Danny Walls.

Improve Your Search (iOS 12+)

Let's leverage powerful and privacy-focused AI/ML tools that are shipped by Apple – like the Natural Language framework – to offer your users smarter search results.

Working with Natural Language framework

Learn how to use the Natural Language framework to analyze text in real time.

Artem Novichkov

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
You can now use the comment section on the website to share your thoughts. Thank you to Runway for sponsoring this issue and thank you to J'aime and Kate for joining us today!

Xcode 16: Try Swift Testing

We encourage you to write your next new test using Swift Testing instead of XCTest. Swift Testing improves your test suite's readability and makes it easier to run certain kinds of tests.

Let's swap out XCTest for Swift Testing:

// import XCTest becomes 
import Testing

// class ExampleTests: XCTestCase becomes 
struct ExampleTests
class ExampleTests // if you want deinit

// override func setup() becomes
init()

// override func teardown() becomes
deinit()

// XCTAssert calls become one of these
#expect(...) 
#expect(customVariable > 10)
#expect(throws: ) { ... } 
#expect(throws: CustomError.self) { ... } 
#expect { ... } throws { ... }

// XCTFail becomes
Issue.record("Custom failure message")

// Prefix your test functions with the Test macro
@Test func ...
@Test("Custom display name") func ...

We like that multiple XCTAssert formats are collapsed into the new expect macro, due to some cleverness under the hood. For more examples, check out Majid's article on the basics of Swift Testing.

Introducing Swift Testing. Basics.

Swift Testing is a new framework with expressive and intuitive APIs that improve your testing experience. It is powered by macros that allow you to organize and assert your tests. This week, we will learn about the basics of the Swift Testing framework and how we can use it side-by-side with XCTest.

Swift with MajidMajid Jabrayilov

Secrets to Success With @MainActor

Swift 6's (included in Xcode 16) stricter concurrency checks inspire us to discuss our do's and don'ts. The MainActor attribute is a hot topic because it has consistently caused confusion since Swift 5.5; here are some secrets to success with this attribute.

DO: add the MainActor attribute to all your observable classes

@MainActor @Observable
class ...

DO NOT: use actors for your observable objects

// DONT DO THIS
@Observable
actor ...

// NOT THIS EITHER
@CustomGlobalActor @Observable
class ...

If you kickoff a background task, make sure you return to the MainActor if it needs to be there for completion.

Task { @MainActor in
  // Do stuff
}

For an example using ObservableObject (we use the newer Observation framework's @Observable in the above code snippets) or for more ways to return from a background task, check out the following article by twostraws.

How to use @MainActor to run code on the main queue - a free Swift Concurrency by Example tutorial

Learn Swift coding for iOS with these free tutorials

Hacking with SwiftPaul Hudson twostraws

More Secrets to Success With @MainActor

We will all run into this. One day, Swift 6 will give you a confusing error that you have a "call to... main actor... in a synchronous context". Prove us wrong and avoid this error entirely with the following DONT.

DO NOT: call your main actor method synchronously from code that could execute on a thread that is not the main thread. In Swift 5.x, this will cause the @MainActor annotation to be silently ignored and the method will not be called on the main actor:

DispatchQueue.global().async {
  exampleMethod()
}
...
@MainActor
func exampleMethod() {...} 

To reflect on MainActor as a global actor, learn to create your own global actors, and review more ways to use the MainActor attribute, you can go deeper with Antoine van der Lee here:

MainActor usage in Swift explained to dispatch to the main thread

MainActor in Swift replaces DispatchQueue.main and ensures tasks are performing on the main thread in a performant manner.

SwiftLeeAntoine van der Lee

Customising Writing With Intelligence

When it comes to Apple Intelligence - available in iOS 18 - the most currently visible feature is Writing Tools. Writing Tools uses AI to offer to rewrite your text.

We use the new writingToolsBehavior modifier to customize Writing Tools on any Text, TextEditor, or TextField.

.writingToolsBehavior(.autocomplete) // default
.writingToolsBehavior(.complete) // turn it on
.writingToolsBehavior(.disabled) // turn it off
.writingToolsBehavior(.limited) // simplified

This article provides further customization of WritingTools through UIKit and discusses the features, animations, and ubiquity of Writing Tools.

Exploring Apple Intelligence: Writing Tools

Understand Writing Tools, powered by Apple Intelligence.

Create with SwiftAntonella Giugliano

Swift Evolution Proposals

[Accepted] We are delighted to see that trailing comma in comma-separated lists has been accepted. This will make for smaller diffs and make it easier to append, remove, and re-order comma-separated lists. 

[In Review] Does the lack of a native Vector type concern you? Or do Arrays adequately serve your needs?

Upcoming Events

• Black Friday Deals: Like last year, Marius Landwehr's Github offers a master list of Black Friday deals. We recommend bookmarking this (it will grow) for returning to on Black Friday. 
• Advent of Code returns with free daily Swift challenges starting December 1
• Mikaela Caron and Paul Hudson are back with Swift Over Coffee, discussing everything from Apple Intelligence to Swift 6. Next episode’s poll: what are your Swift papercuts?

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
You can now use the comment section on the website to share your thoughts. Thank you to KeyboardKit Pro for sponsoring this issue and thank you to J'aime and Kate for joining us today ❤️

Whew! What a whirlwind summer and fall, eh? WWDC Announcements, Swift 6, AI advancements, plus in-person conferences and events are making a comeback. We have a few selections from these developments here for your reading pleasure.

Thank you, Marina, for welcoming me to join you for this week's iOS Code Review. It's been heaps of fun putting this issue together with you.

– J'aime Ohm, enjoyer of newsletters and director of One More Thing

Swift 6: Typed Throws

Throwing functions can now throw typed errors. You can add a type throws(ErrorName) in the function declaration. Or, add a type in a do(ErrorName)...catch declaration.

swift-evolution/proposals/0413-typed-throws.md at main · swiftlang/swift-evolution

This maintains proposals for changes and user-visible enhancements to the Swift Programming Language. - swiftlang/swift-evolution

GitHubswiftlang

How do we make illegal states unrepresentable?

DONT: have a model that supports an `illegal state`, like modeling no payment method (nil, nil) as shown below.

struct PaymentMethod: Codable {
  let creditCard: CreditCard?
  let giftCard: GiftCard?
}

DO: have a model that supports only `legal states`, like modeling only one or more payment methods, as shown below.

enum PaymentMethod {
  case creditCard(CreditCard)
  case giftCard(GiftCard)
}

This article has various examples of the clever use of Swift types to make such states impossible.

Making illegal states unrepresentable | Swiftology

In state modeling, perfection is achieved not when there is nothing more to add, but when there is nothing left to take away.

SwiftologyAlex Ozun

@Entry in SwiftUI

This macro condenses the declaration of Environment, Transaction, Container, and Focused values.

extension EnvironmentValues {
    @Entry var myCustomValue: String = "Default value"
}

Read about the before-and-after in the article below, and check out official documentation

New in SwiftUI: the macro @Entry — Swift with Vincent

You’re more of a video kind of person? I’ve got you covered! Here’s a video with the same content than this article 🍿

Swift with VincentVincent Pradeilles

Videos from SwiftCraft UK 2024

Videos from SwiftCraft UK are up on YouTube. Thank you again to SwiftCraft UK for sponsoring this newsletter in March and April of 2024.

Copilot for Xcode is here

The popular AI coding tool Copilot has now been released by Github as an offical extension for Xcode. To try it you need to disable Xcode 16's predictive code completion.

GitHub Copilot for Xcode

Microsoft released an Xcode extension in a surprising turn of event

MediumThomas Ricouard

A couple of how-tos

Improving User Privacy in Multitasking by Blurring Views
When the environment variable scenePhase changes to inactive or background, sensitive views can be animated with blur by using modifier .blur(blurRadius: to 20. 

Implement blurring when multitasking in SwiftUI

Learn how to implement automatic screen blurring in SwiftUI apps to enhance user privacy when the app enters multitasking mode.

Create with SwiftGiovanni Monaco

When you really really really need your app reviewed quickly
Go to contact us at the bottom of developer.apple.com and keep selecting an option with App Review in it until you reach Expedited App Review Request.

How to expedite an app review on the App Store

A guide on how you can use expedited app reviews in exceptional circumstances to get your app reviewed faster than normal on the App Store.

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
You can now use the comment section on the website to share your thoughts.
Thank you to Runway for sponsoring this issue and thank you to J’aime for joining us today ❤️

I'm really excited about a recent addition to the website - the comment section! Now all registered users (ie all email subscribers) can leave public comments on the issues. If you don't see the comment section - click "Sign in" to get the magic link to your email.
Looking forward to engaging in the open dialog or just reading your thoughts. And of course your emails are always a warmth to my heart :)

Now let's dive in!

Ask WWDC AI

Someone (Matt Spear) built an AI Q&A layer on top of WWDC database. You can ask it any prompt and it will spit out a detailed answer together with links to relevant WWDC sessions. Here's my example about RoomPlan. This is genius.

Ask WWDC

Catching up on WWDC? Ask a question and we’ll give you a concise summary and recommend the most relevant sessions to watch!

Ask WWDC

Scroll view margins in SwiftUI

TIL about contentMargins available in SwiftUI from iOS 17 - the margin is added to the entire content of the scroll view. No need for extra spacers anymore 😬 There are various visual examples in the article 👇

Insetting Scrollable Views’ Content With contentMargins In SwiftUI – SerialCoder.dev

Adding margin to content of scrollable views in SwiftUI is just a matter of a single view modifier. Read here all you need to know about it.

SerialCoder.devGabriel Theodoropoulos

Swift Regex examples

If you’ve ever struggled with regular expressions in Swift, this GitHub repo offers a clean and practical set of examples using Swift’s native Regex type:

GitHub - DandyLyons/NativeRegexExamples: A crowd sourced repository for examples of Swift’s native Regex type.

A crowd sourced repository for examples of Swift’s native Regex type. - DandyLyons/NativeRegexExamples

GitHubDandyLyons

Aaaaand an online playground for playing around with Swift Regex:

Swift Regex: Learn, build and test Swift Regex

Regular Expression Tester with highlighting for Swift Regex. Quickly test and debug your regex and Regex Builder.

Swift Regex: Learn, build and test Swift Regex and Regex Builder.

Enormous SwiftUI app architecture guide

Building large-scale apps in SwiftUI can be tricky, and a modular architecture is our friend. I dug up this super extensive article – sometimes that's just what you need 😀
When it comes to app architecture, taste plays a big role, but nonetheless one can find useful bits. I loved the idea of skipping the MVVM pattern and letting views talk directly to models, at least sometimes, not over-complicating areas of the app that can be kept simple.

Building Large Scale Apps Swiftui

Building Large-Scale Apps with SwiftUI: A Guide to Modular Architecture

AzamSharpMohammad Azam

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Runway for sponsoring this issue ❤️

Your comments in the comment section or direct replies by email are always welcome!

I started a new full time job as an engineering manager in a small startup in climate space called Lun. I'm still coding, alas not as much as before. The project is heavy on iOS specific tech in AR space which I feel is rare in startups nowadays, and I'm loving it! Loved it so much that after consulting with them for a few months, I accepted their offer to join full-time.

It's wasn't an easy decision to let go of the "indie dream" (at least for now), but I'm actually very happy with it - turns out I thrive around other people 😀

Now that I've adjusted to the 9-5x5 again, I feel energised to bring the newsletter back in. Having said that, I'm looking for a partner to get the project going full steam. If that sparks curiosity, write me 👀

Now, let me share a few articles that grabbed my interest:

Typesafe identifiers, my favourite way

On my favourite topic of type-safe identifiers in Swift, Jacob wrote up exactly the way I prefer to manage them by defining a struct for each, but making it a one-liner to do so, no macros involved.

Humans write code, and humans make mistakes. | Jacob Zivan Design

One thing I’ve learned is to **just freaking** let the compiler prevent me from making mistakes. Sometimes that’s hard to do, then I learned about something called a Domain Primitive and I decided to give it a try in Swift.

Jacob Zivan Design

Concurrency in detail

Two articles that are a perfect for each other. Diving into Swift Concurrency, a guide I didn't know I needed when starting with it a while back. And some things to watch out for to avoid subtle bugs when introducing Swift Concurrency into existing large codebases.

How to shoot yourself in the foot with Swift Concurrency - Too Many Tasks

Adopting async/await and Swift Concurrency in a large codebase can cause subtle bugs to creep in your code. Here are some things to watch out for.

Jaim ZuberJaim Zuber

Format styles in excruciating detail

Along with closure syntax and if-case-let syntax, format styles warrant their own guiding website of this sort. While I could find logical mnemonics for closures in Objective-C and for if-case let, SwiftUI's format styles still break my brain every time. Bookmarking this!

Format Styles In Excruciating Detail

Gosh Darn Format Style!

Beautiful async buttons

Spotlighting a library I found myself enjoying oddly much. ButtonKit offers a button component that supports async actions - with beautiful out-of-the-box progress styles and a whole bunch of customisations.

GitHub - Dean151/ButtonKit: Asynchronous and Throwable button implementation for SwiftUI, with animations and progress tracking

Asynchronous and Throwable button implementation for SwiftUI, with animations and progress tracking - Dean151/ButtonKit

GitHubDean151

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Goodbye GeometryReader, hello containerRelativeFrame

From iOS 17 we can use containerRelativeFrame(_:alignment:) for giving views size calculated from the size of its parent. containerRelativeFrame(_:count:span:spacing:alignment:) is to be used when multiple views will be visible in the container.

Refer to official documentation for in-depth explanation, or to a video by Flo for a quick overview:

containerRelativeFrame(_:alignment:) | Apple Developer Documentation

Positions this view within an invisible frame with a size relative to the nearest container.

Apple Developer Documentation

containerRelativeFrame(_:count:span:spacing:alignment:) | Apple Developer Documentation

Positions this view within an invisible frame with a size relative to the nearest container.

Apple Developer Documentation

New Content Margins modifier

Another handy iOS 17 addition in SwiftUI is a view modifier called contentMargins . It allows to inset the content of some of the system views, without getting additional side effects that come from adjusting the safe area:

Content margins in SwiftUI

SwiftUI introduced a set of view modifiers, allowing us to manage the safe area in our views efficiently. In many cases, the safe area is where you want to put your content. Today, we will learn about the new content margin concept that SwiftUI introduced and how it differs from the safe area.

Swift with MajidMajid Jabrayilov

Computed property or a function

func name() -> String or var name: String , func nearestNeighbour() -> String or var nearestNeighbour: String ? There are conventions in Swift that will help you decide:

Deciding between a computed property and a function in Swift – Donny Wals

In Swift, we can use computed properties to derive a value from other values defined on the same object. Being able to do this is super convenient because it means that we don’t have to manually make…

Donny Walsdonnywals

Overrated Swift features

In this article you'll read about a few Swift features that seem cool but do more harm than good when overused: implicit initialisers with .init, subscripts, and more:

The cool Swift features that you should not (ab)use

As an iOS developer, I used to work on a lot of legacy code, or I tried some Swift features myself. After using them or seeing some of them…

MediumChristopher Saez 📱

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Pragma Conference for sponsoring this issue ❤️

Everything about the AASA file

"The Apple App Site Association (AASA) file enables iOS features like Universal Links, Shared Web Credentials, Handoff, and App Clips by establishing a secure and verified link between your iOS app(s) and a web domain. 

If you've noticed that certain links on the mobile web versions of Instagram or YouTube keep you in the browser, while others redirect you into the app, this behavior is all being driven by the AASA file."

Everything You Need To Know About The Apple App Site Association File

The Apple App Site Association (AASA) file enables iOS features like Universal Links, Shared Web Credentials, Handoff, and App Clips by establishing a secure and verified link between your iOS app(s) and a web domain. If you’ve noticed that certain links on the mobile web versions of Instagram or

Digital BunkerAryaman Sharda

ContentUnavailableView FTW

I shared something about this new view back when iOS 17 was just released. Coincidentally, now I'm using it in a project for real for the first time, and a few days later another article came out - with examples of its possible states, and screenshots! At first I wasn't sure that my view was looking the way it should, and I looked for ways to adjust spacing. It's not possible, but I can see that my view looks just the way it is expected to, so I'll leave it be :)

Display empty states with ContentUnavailableView in SwiftUI

Learn how to use the ContentUnavailableView to represent empty states in a SwiftUI application.

Create with SwiftPasquale Vittoriosi

Overcoming obstacles

Obvious to more seasoned engineers, these techniques are the way to go when you're stuck:

5 Practical Ways to Quickly Overcome a Programming Obstacle

Are you stuck on a programming challenge? Does the code not compile? Does the API work differently than you expect? Little problems can add up and get in the way of seeing the big picture. As a software developer, you need to be able to overcome these obstacles. Here are

Super Easy AppsPaul Solt

There is no right or wrong in software engineering (often)

"... when it comes to software engineering, the reality is most things cannot be cleanly divided into "right or wrong" boxes like that. Yes, some things are concrete and indisputable. If an OS-level API states that you should never call it outside of the main thread, then that's what you should follow.
But most things are the opposite of that. When we talk about general problems and best practices, it's extremely rare for them to have a clear right or wrong to go. Instead, they depend on what you're trying to achieve, and everyone is trying to achieve something different.There is no right or wrong in these situations, only different approaches. "

I subscribe to this approach, highly recommend reading this article if you're aiming at senior level or above:

There is no right or wrong in software engineering

Developers love to argue about which tools and languages are better. In this article, we’ll see that things are not that straightforward in practice.

SwiftRocksBruno Rocha

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Handling family shared in-app subscriptions

Apple's sample code for managing in-app purchases has a line of code that is seemingly innocent, but in fact makes the example not support Family Sharing for in-app subscriptions:

subscriptionGroupStatus = try? await subscriptions.first?.subscription?.status.first?.state

Here status is an array and any the elements can be in a subscribed status:
" ... With Family Sharing, the people who are using the subscription act independently: one may subscribe for a year and then cancel. Then another could subscribe at a later date for only a month. You have to check all of the subscriptions, not just the first one. ... "

App Store Subscriptions and Family Sharing • furbo.org

A toot by my friend Casey brought back some frustrating memories about expired subscriptions that haven’t expired (yes, really). This blog post will hopefully help you avoid having these same recollections. It all begins when a customer contacts you with a screenshot that looks something like this: Your code and the App Store don’t agree […]

Furbo.org by Craig Hockenberry

Date decoding strategies in Swift, with examples

We don't usually use the default .deferredToDate decodingStrategy of the JSONDecoder/JSONEncoder, and here's a nice article walking through the different options and when you want to use them:

Date decoding strategies in Swift [with Examples]

The JSONDecoder class uses several decoding strategies to decode dates encoded using different formats in JSON data.

Matteo ManferdiniMatteo Manferdini

Trigger value pattern in SwiftUI

" The recent version of the SwiftUI framework introduces a trigger value pattern across its APIs. Trigger value allows us to attach a view modifier that runs its action whenever the trigger value changes. You can find this pattern while using sensory feedback or launching keyframe animation in SwiftUI. This week, we will learn how to build custom view modifiers using trigger value pattern. "

Here's an example of a SwiftUI API using this pattern:

struct TriggerValueExample: View {
    let messages: [String]
    
    var body: some View {
        List(messages, id: \.self) { message in
            Text(verbatim: message)
        }
        .sensoryFeedback(.impact, trigger: messages)
    }
}

Trigger value pattern in SwiftUI

The recent version of the SwiftUI framework introduces a trigger value pattern across its APIs. Trigger value allows us to attach a view modifier that runs its action whenever the trigger value changes. You can find this pattern while using sensory feedback or launching keyframe animation in SwiftUI. This week, we will learn how to build custom view modifiers using trigger value pattern.

Swift with MajidMajid Jabrayilov

WWDC'23 videos are now on YouTube

All videos from WWDC'23 are now available on YouTube, nicely grouped into themed playlists 🎉

Apple Developer

Hello and welcome to the official Apple Developer YouTube channel.

YouTube

WWDC'24 Special Event application

Tonight is the deadline for requesting to participate in the in-person event at this year's WWDC. If that's your type of thing, you can apply here:

WWDC24 Apple Park Special Event

We’re hosting a special all-day experience at Apple Park on June 10 to kick off WWDC24.

Apple Developer

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Thank you to Swift Craft conference for sponsoring this issue ❤️

What's new in Swift 5.10

Swift 5.10 achieves an even further level of concurrency checking - preventing the app from data races and undefined behaviour.

"
An increasingly important source of undefined behavior is concurrent code that inadvertently accesses memory from one thread at the same time that another thread is writing to the same memory. This kind of unsafety is called a data race, and data races make concurrent programs exceptionally difficult to write correctly. Swift solves this problem through data isolation provided by actors and tasks, which guarantees mutually exclusive access to shared mutable state. Data isolation enforcement has been under active development since 2020 when the Swift concurrency roadmap was posted.
...
In Swift 5.10, full data isolation is enforced at compile time in all areas of the language when the complete concurrency checking option is enabled.
...
The Swift 6.0 compiler will offer a new, opt-in Swift 6 language mode that will enforce full data isolation by default, and we will embark upon the transition to eliminate data races across all software written in Swift.
"

Read about the new checks and errors in Swift 5.10, which complete years of iterative development and prepares us for Swift 6:

Swift 5.10 Released

Swift was designed to be safe by default, preventing entire categories of programming mistakes at compile time. Sources of undefined behavior in C-based languages, such as using variables before they’re initialized or a use-after-free, are defined away in Swift.

Swift.orgApple Inc.

Have you tried Observation framework?

I've stumbled on three articles that are perfectly timed to my interest in understanding the Observation framework. Observation framework is iOS 17+ only, but iOS 18 is just around the corner, so it's a good time to learn more about Observation. Here they are!

The official, step by step guide on migrating your models, with sample code:

Migrating from the Observable Object protocol to the Observable macro | Apple Developer Documentation

Update your existing app to leverage the benefits of Observation in Swift.

Apple Developer Documentation

If the official documentation is not your style, Donny Wals has written an article on comparing the old and the new approach:

Comparing @Observable to ObservableObjects – Donny Wals

Find out how you can leverage the new @Observable macro in your apps. You’ll lean how it compares to ObservableObject and whether it makes sense to switch

Donny Wals

Unit testing Observable models

When your view models are @Observable and use the new Observation framework, the Combine-based unit tests won't work anymore. Jacob shows how he uses withObservationTracking in his code to test the new models:

Unit Test the Observation Framework

Make your iOS 17 view models rock-solid

Jacob’s Tech TavernJacob Bartlett

Accessibility Representation modifier

Here's the key parts from the article, couldn't say it better than the author himself:

"
In app development, it's not uncommon for two distinct views to have the same appearance and functionalities, despite being implemented differently. ... For example, an Image view with an onTapGesture modifier may appear and function like a Button component, but the VoiceOver experience can be completely different.
...
The accessibilityRepresentation(representation:) modifier in SwiftUI is designed to transform how an app's elements are perceived by assistive technologies, such as VoiceOver. ... This modifier allows developers to provide alternative representations of their components that are more accessible for users using assistive technologies, ensuring that the app's functionality is accessible to everyone.
"

Check out code examples in the full article:

Making a view accessible using the Accessibility Representation modifier

Learn how to ensure the accessibility of your custom views by replacing their accessible representation.

Create with SwiftPasquale Vittoriosi

✌️

Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email.

Thank you to Swift Craft conference for sponsoring this issue ❤️

Type-driven design

In issue #62 I shared an article from Swiftology talking about a pattern called TypeState, where types are used to restrict code from moving to incorrect states. Now there's more in that article series.:

Type-safe validation: instead of checking if an email is valid and deciding whether to proceed with logic, what if a value of Email struct can only be constructed if the email matches the requirements?

Type-safe access control: similarly, instead of a Bool controlling access to a certain feature, what if a feature flag was a struct that can only be constructed if allowed? This "proof" value can then be passed along to views that are only allowed to exist if the feature is enabled.

These are really cool approaches. Get inspired to look at the type system in a new light!

Type-safe validation | Swiftology

Validation is a very common task in software engineering. We need to validate stuff all the time: user inputs, data formats, array bounds, external configurations, etc. In this article I will show you how to perform validation in a type-safe way, eliminating a whole class of bugs.

SwiftologyAlex Ozun

Witness pattern — type-safe access control | Swiftology

A common challenge in software design is ensuring that access to a certain functionality is restricted under specific preconditions. In this article, I will show you how to design bulletproof type-safe access control using the **Witness Pattern**.

SwiftologyAlex Ozun

Verifying associated domains

I remember the pain to verify that associated domains are configured correctly in the app and on the website. Now there's a built in tool:

Combining SF symbols

Check out the video in this tweet - I had no idea it's possible to combine two SF symbols into one by drag and dropping them together. And if you're not yet using the SF Symbols app, here it is

Using inout

Back to code! inout can make Swift code even more reusable - take a look at this example of updating local variables. When I first used inout in a complex code, it wasn't obvious that didSet on the variable was called at the end of the function that takes it as inout. Something to keep in mind!

The power of inout parameters

In Swift, inout parameters can reduce code duplication and the amount of code needed to perform certain tasks. Let’s take a look.

Daniel Saididanielsaidi

Accessing iCloud files

To access files from the file picker correctly, we need to do two things:

• call `startAccessingSecurityScopedResource() and stopAccessingSecurityScopedResource() 
• wrap reading the files in NSFileCoordinator.coordinate(with:queue:byAccessor:) so the access doesn't conflict with another app writing to the file at the same time.

Below is a code example for how to correctly do this:

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Don't write recursive functions in Swift

Apparently recursive functions can cause a stack overflow. TIL! If your data is dynamic and the recursion can get unpredictably deep, better avoid it altogether and use a while loop instead.

Avoid using default enum case

I'm a big advocate for strong typing and compiler checks helping avoid bugs and speed up development. And the most basic example of that is switching over an enum. If we spell out all cases explicitly, when a new case is added, the compiler notifies us of all points that need changing.
If you have a colleague that still needs convincing, this is a nice short article on the matter :)

Swift enums and the danger of the default case

How not to lay traps for future developers

MediumToby O’Connell

Previewing CIImage in the debugger

Did you know you can quick-look items in the variables pane of the debugger? That includes not only plain data such as strings and arrays, but also UIImage variables. Even more, a CIImage variable preview includes additional information such as transforms. Check out that little 👁️ icon in the debugger panel! Mike here shares a demo video in the tweet 👇

On separating UI and logic

Can't decide on the view / logic boundary? Ask yourself: “What if this feature should also work as a Command Line Tool?”. I've been personally using this approach for architecting a clear separation and API surface for the domain logic. I love seeing a full-feature article describing this way of thinking:

What if your feature was a Command Line Tool?

When working with UI, it can sometimes be ambiguous where to place business logic. By imagining our features as a Command Line Tool, this can become quite clear.

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

PS. This time I'm trying a new way of embedding tweets. Send me your feedback on how that shows up in your email client.

You might have noticed that this email comes from a new email address. This change was necessary for the new sending requirements for Gmail and Yahoo inboxes - so emails come from the trusted domain ghost.io.

That's also why I had to remove the  symbol from the email subject and sender - else it lands in gmail spam.

To make sure the newsletter doesn't land in spam in the future, mark it as starred, add the new email to contacts, or move it to your primary inbox if you use gmail.

Now let's dive in!

Serialising dictionary writes correctly

Did you know that dict[id] = data actually does two operations: first, reading the current state using the property getter of dict and then setting the new modified dictionary with the setter.

So when we want to make sure that access to the dictionary is performed serially from the same queue, it's not enough to add DispatchQueue.sync to willSet of the property.
In his article Toomas shares his story of uncovering an intermittent issue caused by an incorrect implementation and finding fix.

Avoiding subtle mistake when guarding mutable state with DispatchQueue

Last week, I spent quite a bit of time on investigating an issue which sometimes happened, sometimes did not. There was quite a bit of code involved running on multiple threads, so tracking it down…

Augmented CodeToomas Vahter

Document directory path changes

When persisting local file urls (to CoreData or elsewhere) we need to use relative urls and append the documents directory base path in runtime. Full urls to files in the documents directory might become invalid in the future. TIL!

What if we stopped nitpicking?

Some time ago I was asked one of those questions in an interview, what would I do differently today compared to the past. I had the answer - as a lead developer, I'd allow for more creative freedom in the codebase, and move away from too rigid coding guidelines that govern every little detail of writing code. There are things that matter, and things that don't. Rules that make sense for public APIs and foundation code don't necessarily make sense for feature code that changes often.

When I stumbled on this 3-year old article about the impact of nitpicking on the team culture, I could relate to it so much. Nowadays my reviews are balanced, and I learned to let go of my perfectionism. But I wish I read an article like this many years ago and didn't have to learn it by experience :D

These days my go-to approach is: automate as much as can be automated, and let the humans do what computers can't - think of architecture, edge cases, UX, and so on.

I loved this quote: "Developers like to imagine that they are composed of nothing but cold, hard logic; but actually, we are humans with unavoidable feelings and emotions."
Dan shares his story of learning the impact of too much nitpicking the hard way.

Stop Nitpicking in Code Reviews

One of the best changes I’ve made at work recently is to stop nitpicking in code reviews. Nitpicking isn’t about code that is wrong but suboptimal. It’s pointing out a variable name that could use a more appropriate word, a conditional that could be formatted more cleanly,

Dan Lew CodesDan Lew

Thinking of 2024

I'm considering to change the newsletter to be weekly, with 3 sections each time, instead of 5 sections every two weeks. It would take a bit more effort, but that way I can share more learnings with all of you! Would you like to receive the newsletter weekly? Please let me know, for example by simply replying "yes" to the email.

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Runway for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

We passed 3000 subscribers over the holidays, a warm welcome to everyone who just joined 👋 I'm grateful to y'all loyal subscribers for being along with the ride 🎉

Let's dive into some learnings 🤿

Naming unit tests

When a test fails, we want to understand what broke. When a name is descriptive, we can get the gist of what broke without reading the test code. It's especially useful when a test failure happens on CI. Jon describes a good formula for naming the tests:

Unit Test Naming: The 3 Most Important Parts | Quality Coding

Have you run tests, gotten a failure, and had to dig through test code to understand it? Use this unit test naming convention for faster feedback.

Quality CodingJon Reid

[UI]Image memory footprint

Memory usage ≠ file size.
"Memory use is related to the dimensions of the image, not the file size." - Session 416, WWDC 2018

To reduce our app's memory footprint and reduce chances of the app being killed in the background, we can:

• make sure there are no memory leaks (in UIKit, views deallocate). Use Debug Navigator (spraypaint icon in Xcode) and Leaks and Allocation instruments.
• downsample images to view size before display (an image larger than its frame uses memory unnecessarily). See the article for how to do it.
• when an image cache library is used, remember to set the memory cache limit.

Reducing Memory Footprint When Using UIImage - Swift Senpai

Learn how to use image downsampling to drastically reduce an app memory footprint when dealing with high definition UIImage.

Swift SenpaiLee Kah Seng

Typestate pattern: next-level type safety

The concept of typestates describes the encoding of information about the current state of an object into the type of that object. I'm a big proponent of using the type system to apply domain constraints, so the compiler checks that logic for us.

In this article you can learn how generics and noncopyable types available from Swift 5.9 help take type safety to another level:

Typestate - the new Design Pattern in Swift 5.9 | Swiftology

In this article I will introduce you to Typestate pattern, popularised by Rust language, now available in Swift 5.9. You will see how the combination of generic constraints and Swift’s new memory ownership model allows you to write bulletproof code.

SwiftologyAlex Ozun

What game are you playing in life?

We are in the beginning of a new year, perfect time to reflect.
Imagine your career as a game. What game is that? What are the objectives? What level are you at, and what quest do you need to complete to advance to the next level? I'm curious to hear in replies what that is for you ☺️

Complete And Total Gamification: Life as a Game

This article is inspired by one of my favourite scenes from Guy Ritchie’s The Gentlemen and a great book called Games People Play, by Eric…

MediumDavid Babayan

New video alert

I visited The Mayank Show to share my insights on becoming a lead developer. We talked about boosting your career, moving abroad, system design, mentoring, running a newsletter, conferences, and what's different between 2011 and now 😁

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

* this issue contains an affiliate link to Setapp

UIViewController viewIsAppearing

Unlike viewWillAppear, by the time viewIsAppearing is called, the view has been added to the view hierarchy, has accurate geometry, including size and safe area insets. Available from iOS 13!
Using this method, it's a breeze to add animations to the content of the view controller that have to execute when the view first gets shown.

From viewWillAppear to viewIsAppearing - Perfecting Your iOS View Transitions

In WWDC23, Apple introduced a nuanced addition to the UIViewController lifecycle: viewIsAppearing. This instance method is a game-changer for developers looking to fine-tune the presentation and layout of their views. Let’s explore how this method enhances the way we build responsive and dynamic interfaces.

OhMySwiftRizwan Ahmed A

Catching memory leaks on CI

It's annoying how easy it is to accidentally introduce memory leaks into our code. Just a little self sneaking into a closure past a code review, or an omitted self causing troubles when passing a method in place of a closure. We can add checks to unit tests verifying certain objects get deallocated, but it's not nearly possible to catch everything. We can use the leaks instrument (included with Xcode) to see if the app has any memory leaks at any given moment.

Here's a brilliant approach to automating catching leaks on CI:
1. Use a UI testing framework to simulate the flow in the application
2. Use the leaks tool provided by Apple to generate a memgraph.
3. Write a script to process the generated memgraph to check for leaks. If there any leaks are found, use Danger to mark the PR as failed or post a message to Slack.

Automating Memory Leak Detection with CI Integration for iOS

A solution to automate memory leak detection in iOS Development

Level Up CodingTuan Hoang (Eric)

Opening SFSafariViewController, cleanly

In SwiftUI, we can utilize .openURL environment variable to catch any element trying to open a link, and, for example, open it in an embedded browser instead. Moving that logic into a view modifier, the usage site becomes so clean 🤩 Check out Antoine's article for the full code.

struct SwiftUILinksView: View {
    var body: some View {
        VStack(spacing: 20) {
            /// Creating a link using the `Link` View:
            Link("SwiftUI Link Example", destination: URL(string: "https://www.rocketsim.app")!)

            /// Creating a link using markdown:
            Text("Markdown link example: [RocketSim](https://www.rocketsim.app)")
        }
            /// This catches any outgoing URLs.
            .handleOpenURLInApp()
    }
}

SFSafariViewController in SwiftUI: Open webpages in-app

Use SFSafariViewController in SwiftUI and catch any outgoing URLs to ensure they open in-app instead of in the external Safari browser.

SwiftLeeAntoine van der Lee

Ultimate SwiftData guide

For anyone looking for a clear roadmap for the journey of learning SwiftData, this is it. One of the longest articles I've ever seen, but you don't need to jump around a ton of different articles and WWDC videos. Although, I always recommend reading official documentation and watching official videos.

The Ultimate Swift Data Guide

The Ultimate Guide to Building SwiftData Applications

AzamSharpMohammad Azam

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Runway for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

I'm excited to bring you another curated selection of learnings. Grab a warm beverage and dive in!

For this special issue, I'm happy to feature a set of tools built by my good twitter-friend Daniel Saidi. We've had parallel careers, in the same 4 years working as lead iOS developers in competing book subscription services in Scandinavia, and then going indie at the same time. I'm always happy to bring more recognition to indie tools, and I am grateful for Daniel's support of the newsletter ❤️

Alternative to Spacer

Using a .frame modifier can save you a lot in performance over a Spacer, especially in lists or long horizontal/vertical stacks. David shares a number of scenarios where we can replace a Spacer with .frame and get the same behaviour:

The alternative to SwiftUI’s Spacer

Early on, SwiftUI introduced Spacer. But did you know that you can replace it with something else in most use cases?

David YangDavid Yang

Pin SwiftUI view to an edge

From iOS 15, there’s a handy safeAreaInset that allows us to place additional content extending the safe area. Without safeAreaInset, we'd have to manually calculate height of the additional content and adjust scroll view content insets manually. safeAreaInset is available from iOS 15 🙌

How to show anchor bottom view in SwiftUI

Issue #954 From iOS 15, there’s a handy safeAreaInset that allows us to place additional content extending the safe area. Shows the specified content beside the modified view. safeAreaInset allows us to customize which edge and alignment we can place our views. This works for both ScrollView, List…

Swift DiscoveryKhoa Pham

Living with flaky tests (temporarily)

Sometimes tests are failing, and we can't fix them right away. That might be the case during a lengthy refactoring process, or we might have a flaky test that fails sometimes.
While it's a viable workaround to re-run the flaky test, or comment out failing ones, XCTest has an XCTExpectedFailure API that allows a test to fail temporarily:

let options = XCTExpectedFailure.Options()
options.isStrict = false
XCTExpectFailure("Working on a fix for this intermittent problem.", options: options)
XCTAssertTrue(true, "This always works.")
XCTAssertTrue(testResultOfSomeActivity, "This only seems to work half the time.")

Read Leonardo's article that goes in depth on various scenarios when this API could be useful:

Unit Test Expected Failures in Swift - Holy Swift

Explore managing expected failures in Swift’s XCTest with expert insights on balancing hard and soft skills in iOS development.

Holy SwiftLeonardo Maia Pugliese

Reusable components without extra effort

Okay, almost :) The idea is to employ more generalised naming of types as a guide to whether the component is reusable in your code, and use variable names for context. Here's an example:

// Before
let moneyBuddyCard = MoneyBuddyCard(...)
let adviceView = AdviceView(...)

// After
let moneyBuddyCard = DecoratedCardView(...)
let adviceView = DecoratedCardView(...)

Deliver reusable components without making them reusable

Reusability and duplication are tough to balance. What if I told you that, sometimes, you don’t have to?

Writing better documentation

Editing is an important step in the process of writing documentation. Google has crafted a short, yet comprehensive guide to elevate your technical writing skills. I was amazed by how applying these simple rules transforms my writing.
At the end there's an exercise to improve this bit of text:

Determine whether or not you can simplify your document through the use of terminology that is equivalent but relatively shorter in length and therefore more easily comprehensible by your audience. It's important to make sure your document is edited before it is seen by your audience, which might include people that are less or more familiar with the matter covered by your document. The first thing you need is a rough draft. Some things that can help make your document easier to read are making sure you have links to background information, and also checking for active voice instead of passive voice. If you have long sentences you can consider shortening them or implementing the use of a list to make the information easier to scan.

I encourage you to try the exercise, and share your results!

Self-editing | Technical Writing | Google for Developers

Google for Developers

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Daniel with KeyboardKit for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Swift Algorithms - split an array into chunks, and more

If you google "how to split an array into chunks in Swift", you'll get a bunch of results showing how to implement a function that can split an array, called chunked().
Another example we commonly need is removing duplicate elements from an array.

However implementing these function by yourself is not ideal (and having to write all the unit tests!). Gladly many such functions are already provided by Apple, in a lesser known package called swift-algorithms.

swift-algorithms package has various functions that are not (yet) included in the standard library. As for the reason why these functions are not in the standard library, the announcement post on swift.org sheds some light:

It’s our ambition for the standard library to include a rich, pragmatic set of generic algorithms. We think the Algorithms package can help realize this goal by serving as a low-friction venue to build out new families of related algorithms—giving us an opportunity to iteratively explore the problem space and learn how different algorithms connect and interact—before graduating them into the standard library.

Aside from .chunked() and .unique(), the package contains many other useful algorithms such as:

• creating permutations from elements in a collection
• rotation of elements in an array
• selecting a random part of a collection
• getting a certain number of min/max elements
•  iteration over tuples of adjacent elements
• and many more

There are a number of benefits to using this package - each algorithm is thoroughly tested, peer reviewed, and improved for best possible performance, which is also documented for each algorithm.

Announcing Swift Algorithms

I’m excited to announce Swift Algorithms, a new open-source package of sequence and collection algorithms, along with their related types.

Swift.orgApple Inc.

GitHub - apple/swift-algorithms: Commonly used sequence and collection algorithms for Swift

Commonly used sequence and collection algorithms for Swift - GitHub - apple/swift-algorithms: Commonly used sequence and collection algorithms for Swift

GitHubapple

Split a list by month

The chunked() function from swift-algorithms is not only allowing to split an array into fixed-size chunks. It also has a variant that allows to provide a custom decision-making closure for when a chunk should end.
Danijela is show casing an example of splitting a list of travel destinations grouped by month. Just be wary that for large amounts of data, it's better to utilise database-backed queries.

Split your data easily and efficiently with .chunked() | Danijela’s blog

Swift Algorithms is an open source package of sequence and collection algorithms. It contains many generic algorithms found in other popular programming languages. In this post, we’ll take a look at how to implement the .chunked() algorithm to chunk an array of data and display it in your UI.

Danijela's blog

GeometryReader - Blessing or Curse?

Some swear by GeometryReader, and some hate it to the bone. Or maybe you haven't had to use it at all. Whichever it is, this comprehensive article will be useful.
The author dives as deep as one can - with benefits and drawbacks, why it works the way it works, and how to hold it right.

GeometryReader: Blessing or Curse?

A good tool is only as good as the person who wields it

Better Programmingfatbobman ( 东坡肘子)

setNeedsLayout() vs layoutIfNeeded()

On the topic of layouts, here's one for UIKit. You'd use layoutIfNeeded() for an immediate update, and setNeedsLayout if you don't mind your changes to be animated.

setNeedsLayout(): 
This method does not force an immediate update, instead it marks the view for the update. It triggers the update during the next update cycle. This is efficient when you have multiple changes to make.

layoutIfNeeded(): 
This method forces the view to update its layout immediately. It ensures that all pending changes, if any, are applied immediately.

Learn the magic of setNeedsLayout() vs layoutIfNeeded() with Nitin Aggarwal. | Naman Sabarwal posted on the topic | LinkedIn

Demystifying the power of setNeedsLayout() vs layoutIfNeeded() setNeedsLayout(): This method does not force an immediate update, instead it marks the view…

LinkedInNaman Sabarwal

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Thank you to Bitrise for sponsoring yet another issue ❤️

Sponsors help me grow my content creation and keep the lights up, so if you have time please make sure to have a look at the survey they're offering ☺️

How (not) to monitor SwiftUI @State

It might be tempting to use didSet to observe variables declared with @State, especially that it seems to work in the basic cases. But it doesn't work when the binding is passed to another view. We need to use the .onChange modifier to observe the variable. I met Dean at NSSpain this year, and I'm happy to share his blog with you all ☺️

How (not) to monitor SwiftUI @State

While I was working on the first version of my latest app SharePal ⚡️, I figured that I’d like to add haptic feedback for distinct action within the app. Something that did not worked well… Since I’m targeting iOS 16 as a base, I…

Dean’s blogThomas Durand

Random enum case

Such elegant solution for accessing a random case of an enum. Here's a gist of it, by a adding a simple extension on CaseIterable, any enum gets such functionality. You can read more about it in Jordan's blog post below.

enum Foo: String, CaseIterable {
    case a, b, c
}

print(Foo.randomCaseIterableElement())

extension CaseIterable {
  public static func randomCaseIterableElement(using generator: inout some RandomNumberGenerator) -> Self? {
    allCases.randomElement(using: &generator)
  }

  public static func randomCaseIterableElement() -> Self? {
    var generator = SystemRandomNumberGenerator()
    return randomCaseIterableElement(using: &generator)
  }
}

Generating Random Numbers Elegantly in Swift

Swift has a useful mechanism to generate random values. Today, let’s see how we can plug in SystemRandomNumberGenerator for our own types.

Jordan MorganJordan Morgan

Launching a SwiftUI view from the terminal

"While there is a lot you can display in the terminal, there is certain information that is better conveyed in a graphical user interface. Contrary to what you might think, you don't need to create a full-blown macOS app to display a simple UI."

Launching a SwiftUI view from the terminal

Learn how to launch a SwiftUI view directly from your Swift command-line tool without making a full-blown macOS application.

Writing better unit tests

A collection of before-and-after examples that demonstrate how to enhance test cases by verifying prerequisites and conditions.

verify(StorageThing)
    .hasNoEntry("something")
sut = UnitBeingTested()
verify(StorageThing)
    .hasEntry("something")

In this example, the first line brings a benefit of verifying that the mocked storage didn't have the value before. Otherwise, the test would succeed even if initialising sut didn't save the value.
You can find many more examples like that in the article:

Writing good unit tests

We write tests to prove that our code is correct now and in the future. If we want to do some refactoring some day then we can rely on…

Dev GeniusChris Mash

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Thank you to Bitrise for sponsoring yet another issue ❤️

onAppear vs task

If you'd like to execute code when a SwiftUI view becomes visible, you have the option of using either onAppear or task. They're not the same though:

• onAppear is executed before the view is rendered the first time. At this point, changes to the view state can be applied without causing any visible flickers, as the view will render with the new state.
• task is executed right after the view appears, so if any state changes are made, they are applied after the initial rendering.

Chris Eidhof has created a sample code that demonstrates the difference, you can find it in his article: Running Code When Your View Appears.
I learned about this from another newsletter Not Only Swift made by Peter Friese 👋

viewIsAppearing - new in iOS 17

On the topic of views appearing, we there's an improvement in UIKit this year. We got a new view controller lifecycle method - viewIsAppearing (documentation).

The primary distinction between viewWillAppear and viewIsAppearing lies in the timing of the callback. The new method is called after the view is added to the hierarchy and got accurate geometry. This means that we can make calculations that depends on the view's geometry before the view appears.
Previously the only option was to use viewWillLayoutSubviews and viewDidLayoutSubviews, and it's not a straightforward solution, because these methods are called more than once.

There's still a place for UIKit

With the advent of SwiftUI, we're asking ourselves - in what scenarios is UIKit still relevant?
Apps heavily based on images are one example. There's nothing yet in SwiftUI that can beat a UICollectionView with a custom layout.
Map clustering is another example. If you need to cluster annotations on the map when the user zooms out, it's not currently possible with pure SwiftUI.

We can still make many screens in SwiftUI, while keeping image-heavy screens or overall navigation in UIKit. There's no key learning here, I just feel it's worth reiterating that not everything can be done in SwiftUI yet.

Crafting Swift Code that's bug-free by design

My talk, titled "Crafting Swift Code that's bug-free by design", was recorded at NSSpain and is finally available - and I'm happy to share it with you.
In case you've been following the newsletter for a while, some of the insights might be familiar. Nonetheless there's something for everyone. I'd love to hear what you found most useful 😊

How iOS apps can be hacked, and what to do about it

My favourite talk from NSSpain, Hacking iOS Mobile Apps by Kamil Borzym shows how a harmful third-party library can steal any data provided by the user, including passwords they type in the app.

Coincidentally, I presented a talk on this topic a year ago, showing how to protect your app from malicious code in a third party library - explaining why and how to vet third-party dependencies. So these two talks make a perfect combo :)

You can also find all other talk recordings from NSSpain 2023 on Vimeo.

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Bitrise for sponsoring yet another issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Are you using SwiftData?

New and fancy alternative to CoreData is much easier to use, but it still has a learning curve. It's declarative, so how we declare the data makes a difference.
With enums in particular, adding raw values makes a huge difference on how the data is stored, so we can reduce database size and make requests faster. On small scales that might not have much difference, but with large amounts of data it's certainly an improvement.

New behaviour of URL(string:) in iOS 17

If you're building your app using Xcode 15, URL(string:) gets a new behaviour. Now invalid urls don't return nil anymore, and get percent-encoded. To get the old behaviour, we need to use URL(string: str, encodingInvalidCharacters: false)

How to make a strong case for accessibility

As one example of accessibility not serving only disabled users, subtitles are not only for deaf users - they also serve those who can't listen at the moment, or are located in a loud environment.
A brilliant infographic, and a brilliant article with a set of practical takes on building a compelling case for supporting accessibility in our apps.

String catalogs in Xcode 15

Xcode 15 finally introduces a better way to handle localizations in a structured way. No more .strings files 😎 Here's a four-minute demo of the new functionality:

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Bitrise for sponsoring this issue ❤️

Over the past two weeks, I had the privilege of attending iOSDevUK and speaking at NSSpain. It was an incredible experience! My talk, titled "Crafting Swift Code that's bug-free by design", was recorded and will be available in the coming weeks - I will share it with you then.

I would like to take a moment to express my warmest welcome to those of you who I had the pleasure of meeting at iOSDevUK and NSSpain, and to everyone who have joined the iOS Code Review community recently. Your presence and engagement mean the world to me ❤️

Today I'm excited to share a few learnings that caught my attention at the conferences.

Cache vs Persistent store

Avi Tsadok talked about building offline-first apps. When we build offline support in our app, it's important to note the difference between caching and persistence. Caching is temporary and it's main purpose is to boost performance and perceived speed of the app. Persistence, on the other hand, allows to operate on the data in offline, providing full offline capability to the app. So before we reach to pick a storage solution, we should understand - are we adding caching or persistence?

Simple app architecture

David Kababyan shared the architecture behind the iOSDevUK conference app. That was a lightnign talk, and the architecture seems nice for a small app like that!

Working with time

Dave DeLong gave an insightful talk about working with dates, drawing an analogy with coordinates on the map. There are real places (points in time), and there are their names in a certain coordinate system or in a certain address system (epoch time, date representation in different calendars or time zones).

What I found particlularly interesting is the difference between setting and offsetting time. When we want to compose a date that means 3 am on a certain day, we have two ways of doing it:
- get the day and set its hour to '3 am'
- get the day's start (midnight) and add 3 hours.
The first might not exist, and the second will always exist.

And it's worth remembering that sometimes we don't need to bother, and 24*60*60 might be fine, for example if we're talking cache expiration.

James Dempsey and the Breakpoints

NSSpain wrapped up with a bang - a performance by James Dempseys' country band - James Dempsey and the Breakpoints. The only band out there that sings about Swift Development 😄 check them out!

James Dempsey and the Breakpoints - Backtrace

Backtrace

and, Swift 5.9 is here!

This is a major new release that introduces macros to Swift, adds bi-directional interoperability with C++, and more. Read the blog post to see what's new.

Using if and switch as expressions is something many have waited for. Let's just try avoid writing code like this (via @krzyzanowskim):

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to friends at Paste for sponsoring this issue ❤️

What was particularly interesting? let me know by replying!

Cleaner grid initialization

Here's Daniel with handy extensions for a simpler way of defining  LazyVGrid and LazyHGrid 's columns:

LazyVGrid(columns: .fixed(100)) { ... }
LazyVGrid(columns: [.fixed(100), .fixed(150)]) { ... }
LazyVGrid(columns: .adaptive(minimum: 100, maximum: 150)) { ... }

Cleaner grid initialization in SwiftUI

SwiftUI’s LazyVGrid and LazyHGrid are great for creating powerful and flexible grids, but I always struggle with how to define columns when creating them. I’ve therefore created some extensions to make this easier. Let’s take a look.

Daniel Saididanielsaidi

Analogue clock on macOS in SwiftUI

Apparently, DatePicker on macOS can be fun, where the user can move clock hands to select a time 🙈

Premature Optimization: Universally Misunderstood

The famous quote actually reads:

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil.
– Sir Tony Hoare

Indeed, once an app is shipped to users, it can be too late to fundamentally change the app architecture, database structure, or API design. Those large aspects should be thought through early, and small optimizations can be done at a scaling stage.

milen.me — Premature Optimization: Universally Misunderstood

“Premature Optimization” You might have come across the famous software optimisation quote popularised by Donald Knuth:Premature optimization is the root of all evil.– Sir Tony HoareIt has been commonly interpreted as “don’t think about performance in the beginning, you can fix any performance pr…

Co-authoring Git commits

Git supports having multiple authors on a commit - so when you're pair-programming with a colleague, they can receive credit for it too.
We simply need to add the credit as extra text anywhere in the commit message - Co-authored-by: <name> <email> :

Tool to find unused code

TIL that there's a tool to find unused code, I always wished there was one. It's called Periphery. I learned about it via Manu, who wrote a nice article on how to set it up for your project:

Use Periphery to find unused code

From time to time, it might be a good idea to spend a couple of hours checking if there is some code in the codebase that is not being used anymore. Luckily for us, there is a tool out there that can make the job easier. Periphery: A tool to identify unused code in Swift projects. Using Periphery on…

manu.showManu Herrera

✌️

I will be at iOSDevUK on the main conference days -  5-7 September, and on NSSpain 14-16 September. If you're there - come say hi!
I'll have stickers to give away 😋  Do you also want a t-shirt with the newsletters logo? Send me your size and I'll pre-make one for you.

Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️

It's almost conference season 🤓 I'm going to a couple of conferences this autumn. I will speak at NSSpain and hopefully get a visa in time attend iOSDevUK. Will I see you there? Let me know if you're also planning to go, let's meet!
If you're not going to any in-person conferences, perhaps check out the online Mobile DevOps Summit by Bitrise, who are so kind to be sponsoring multiple issues of the newsletter ☺️

Also a small personal update: I've changed my last name to Vatmakhter - which is my grandparents family name. It's something I've been wanting to do for many years, and finally I could 🎉☺️ I'll slowly propagate it throughout my online presence - it's still me 😁

Enum-based sheet presentation

Displaying multiple sheets from one view can quickly lead to repetitive code segments in SwiftUI. By using an enum to represent which sheet to present, we can make the code more maintainable. This, and more learnings can be found in Antoine's article below.

Sheets in SwiftUI explained with code examples

Sheets in SwiftUI allow you to present a view on top of another. Learn how you can control multiple sheets using a generic solution.

SwiftLeeAntoine van der Lee

Using #error

Swift has a compiler directive that allows us to issue a compilation error.
This can be useful in a few ways, for example to prevent the app from compiling in certain conditions.
One of my usecases is when you're iterating over a feature and want to merge to develop, and want to make sure the app can't be released in an unfinished state.

func calculateStuff() {
    print("TBD")
#if RELEASE
    #error("calculateStuff feature is not implemented!"
#endif
}

Here's Vincent sharing another scenario, where package authors can use #error in their example code, to bring user's attention where they need to fill out the api key.

Text + Text

A handly alternative to AttributedString in SwiftUI:

A refactoring story

Every codebase has a piece of code similar to this. Here's Jon demonstrating a step-by step refactoring to make it error-proof:

Refactoring: How Do You Clear Up a Mess, Safely? | Quality Coding

When refactoring in small steps, sometimes you have to make a mess to clear up a mess. Download the code and walk through these refactoring steps.

Quality CodingJon Reid

✌️
Alright, that's it for today! Let's spread the good code vibes ✨🧘🌈☀️
Thank you to Bitrise for sponsoring this issue ❤️
And I always want to hear from you -just reply to this email :)

GIFs in SwiftUI

TIL how easy it is to play gif animations in UIKit and SwiftUI using CGAnimateImageAtURLWithBlock. We just need to remember to stop the animation when the view disappears:

View vs View modifier?

Back when I just started learning SwiftUI, I started by making all of my customizations as View. I even had styled text as a View wrapping a styled Text, similar to UILabel subclasses in UIKit 🙈🙈
Fairly quickly though I grasped the idea of view modifiers, still using custom Views for breaking down the view hierarchy and for reusable components.

So when I stumbled on John's article where he explores when to use what approach, I knew I have to share it with you folks. He implements the same "featured" UI using a view and a view modifier, and compares them side by side:

SwiftUI views versus modifiers | Swift by Sundell

What’s really the difference between building a piece of UI as a view versus a modifier, and how to choose between those two solutions?

Swift by Sundell

Beware of Xcode's automatic version management

Alexander shares his surprising experience with Xcode's ability to override version and build numbers during app export. Turns out, it overrides the values in all Info.plist files, including those embedded in third-party SDKs, so you can run into subtle issues if the SDK is checking those values.

AppStore Connect: Manage Version and build number

I have released quite a few apps already, mostly at work but also personally. When releasing, I was facing issues with signing, Xcode configurations, CI/CD solutions or the AppStore Review. I assumed I have seen quite a lot of issues. Recently I was…

Teabyte

Looking up Apple's error codes

Save it for later -> osstatus.com

✌️
Alright, that's it for today.
PS. As Twitter has messed up its API, I still have to embed tweets using screenshots. I'd love to hear your experience with images in the emails - how has that been, are you experiencing any issues with that? Let me know 🙏

* this issue contains an affiliate link to Setapp

Check your third party dependencies

Last year I gave a talk on Mobile DevOps Summit 2022 about protecting your app from malicious code in third party libraries. That's also why I'm extra excited that they're sponsoring the newsletter 😄
In short, code in a framework gets access to your whole view hierarchy and memory, so they could steal your user's data. In the talk I give tips on how to check that a library isn't doing what it isn't supposed to.

You can find all recordings from last year on Youtube.

Shuffling arrays

Don't know who needs to hear this, but there's a set of handy methods for randomly shuffling any array.
There's shuffle() and shuffled(), and companion methods that take a random number generator. A custom generator can implement, for example, a reproducible ordering - while the default one (SystemRandomNumberGenerator) makes it as random as it can be:

shuffled(using:) | Apple Developer Documentation

Returns the elements of the sequence, shuffled using the given generator as a source for randomness.

Apple Developer Documentation

On skipping tests

How does Xcode know which tests to execute? It looks for classes conforming to XCTestCase, and inside them for any method starting with test.
So one way to temporarily disable a test is to comment out or rename the method so it doesn't start with test.
There's a better way though - we can conditionally skip tests by calling XCTSkip, XCTSkipIf and XCTSkipUnless :

XCTSkip your tests | WWDC NOTES

Get the test results that matter — and skip the ones that don’t. Discover how you can implement XCTSkip to conditionally avoid tests at runtime. We’ll take you through how to return this new test result and better document tests beyond pass and fail within your test bundle. To get the most out of t…

WWDC NOTES

Swift Macros - something's coming!

Swift Macros are so powerful, I'm yet to comprehend how much they will change the way we do things in Swift. I'm looking forward to using them in production apps starting from September.
Here's two down-to-earth examples where they can simplify our coding life:

✌️
Alright, that's it for today!
Thank you to Bitrise Mobile DevOps Summit for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Happy WWDC!

I will share my favorites from WWDC 2023 at a later point - but for now, here are notable things available from iOS 15 that are a must for modern UIKit apps 😋

Bar appearance

Definition-based configuration for different states of the UINavigationBar: standardAppearance, compactAppearance,  scrollEdgeAppearance, compactScrollEdgeAppearance. And there's a similar comnfiguration available for UITabbBar 🙂

UIButton styling

Definition-based configuring of the UIButtons, so making a capsule button is almost as easy as in SwiftUI using UIButton.Configuration:

No cell subclassing

It's not necessary anymore to subclass system cells - configurationUpdateHandler lets us hook into state updates and update the cell's appearance. This fits well with the contentConfiguration and backgroundConfiguration of the cell - which again, make configuring cells as declarative as it can get in UIKit 😋 And of course, this is available for both UITableView and UICollectionView.

If we need to make a custom-designed cell, then we can dive into content views - a new way to provide the custom content for the cell. A content view works with a contentConfiguration - and again, it doesn't require subclassing of UITableViewCell/UICollectionViewCell. To learn about it, you can follow Apple's official interactive tutorial:

Using content views | Apple Developer Documentation

In this tutorial, you’ll add capabilities to the app’s editing mode that transform a view-only list of reminder details into editable controls.

Apple Developer Documentation

Structural identity in SwiftUI

Structural identity is how SwiftUI understands your view hierarchy and recognizes particular views without specific identifiers. It is crucial to understand how it works to build great and performant views with SwiftUI:

Structural identity in SwiftUI

Structural identity is the type of identity that SwiftUI uses to understand your views without an explicit identifier by using your layout description. This week we will learn how to improve performance and eliminate unwanted animations by using inert view modifiers in SwiftUI.

Swift with MajidMajid Jabrayilov

And more...

For some less technical reading, my husband David has started a blog where he writes about the tech industry. He's been supporting me throughout my carreer journey, and I can only return the favour 🙂 If you're curious to read about the challenges of running a startup, or how we can fix the state of hiring, check out his writing:

The Flawed Dance of Recruitment: Breaking the Cycle for a Better Hiring Process

Introduction

MediumDavid Babayan

The Silent Killer of Startups: How a Lack of Inspiration Destroys Your Team and Business

In this post, I summarise a decade of my experience, analyse problems that I encountered in every company I worked with and…

MediumDavid Babayan

✌️
Alright, that's it for today!
Thank you to Bitrise for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

The efficiency of +=

The += operator, when performed a non-trivial number times, is much faster than addition and assignment with +.  (the Twitter integration is temporarily out of commission, click on the image to read the thread)

Ranged line limit in SwiftUI

We can specify a number of lines as a range, and SwiftUI will reserve space for the lower bound - even if the text itself takes less space (available from iOS 16)

Roman (@ramzesenok@mastodon.social)

Attached: 1 image - Day 21Setting line limit in #SwiftUI means setting its upper limit. Text will render as many lines as needed for content but no more that the limit. But we can also set a range as a limit. Now it will reserve space for the lower bound and render no more than upper bound lines

Mastodon

Accessibility for custom SwiftUI views

Whenever we make a fancy custom control in SwiftUI, we don't have to spend time making it accessible by itself - instead we can use the .accessibilityRepresentation modifier. Whenever VoiceOver navigation is used, SwiftUI will use the view created by this closure instead of our custom view. By using a system control in this representation, we save on effort while users will be happier 🤩

Roman (@ramzesenok@mastodon.social)

Attached: 1 image - Day 16Sometimes we come up with crazy fancy controls that are very inaccessible. We can try making it accessible here and there or we can also replace them with something very simple yet completely accessible. Here comes `accessibilityRepresentation` in play

Mastodon

Custom scopes in Swift

I love this trick and use it quite a lot. Every set of curly braces is a scope - meaning that variables declared inside it are not available on the outside. Naturally, functions, closures, and if statements are scopes, but no one is stopping us from creating scopes whenever we want - the easiest way to do that is with a do {} syntax.
Why, you ask? This allows to isolate some intricate logic, when you don't want to move out a piece of code to a separate function, but still want some extra separation inside the funciton. Last time I used it for calculating frames inside layoutSubviews.

Roman (@ramzesenok@mastodon.social)

Attached: 1 image - Day 13Ever wanted to somehow scope a portion of logic from the rest? You can use `do {}` for that. Scoping can help you limit lifetime and visibility of some variables resulting in cleaner code and faster app

Mastodon

The importance of code ownership

Most of important and successful projects, even though they started off small, go through different phases that turn a proud shiny code into a piece of cryptic code everyone fears and despises.
In this article you'll read about how and why it happens, and find recommendations on making sure the code is properly owned - and thus maintained.

The Importance of Code Ownership

Well-owned code is well-maintained code

Better ProgrammingElye

✌️
Alright, that's it for today!
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

* this issue contains an affiliate link to Setapp

Lightweight view initialization

Initializer of a SwiftUI view should be as lightweight as possible, as it is executed many times. In fact, it's a good rule of thumb for UIView and UIViewController initializers too - keep the heavier work for the moment when the view loads or appears.

Sorting user-entered strings

Don't just use .sorted() on arrays of strings. A quote from localizedStandardCompare(_:) documentation:

This method should be used whenever file names or other strings are presented in lists and tables where Finder-like sorting is appropriate. The exact sorting behavior of this method is different under different locales and may be changed in future releases. This method uses the current locale.

By the way, Swift's String implementation is so great, that it already treats special characters correctly during equality checks with ==. Using the right comparing method brings the same greatness to sorting of strings 🙌

An example from the Swift docs about equality with diatrics:

The letter é can be represented as the single Unicode scalar é (LATIN SMALL LETTER E WITH ACUTE, or U+00E9). However, the same letter can also be represented as a pair of scalars — a standard letter e (LATIN SMALL LETTER E, or U+0065), followed by the COMBINING ACUTE ACCENTscalar (U+0301). The COMBINING ACUTE ACCENT scalar is graphically applied to the scalar that precedes it, turning an e into an é when it’s rendered by a Unicode-aware text-rendering system.

... Two String values (or two Character values) are considered equal if their extended grapheme clusters are canonically equivalent.

... LATIN SMALL LETTER E WITH ACUTE (U+00E9) is canonically equivalent to LATIN SMALL LETTER E (U+0065) followed by COMBINING ACUTE ACCENT (U+0301). Both of these extended grapheme clusters are valid ways to represent the character é, and so they’re considered to be canonically equivalent

Read the article from the tweet to learn about more ways of sorting arrays of strings.

Modern UISegmentedControl

Lovely modern API for reacting to UISegmentedControl selection, that doesn't require @objc methods anymore:

Avoiding junk in the git diff

Inside each .xcodeproj and .xcworkspace file there is a folder called xcuserdata, containing files that are individual to each user who opens the project - that users breakpoints, saved search scopes, and other configurations. xcshareddata folder contains files belonging to the whole project such as schemes and the Package.resolved file.
💡 xcuserdata folder should be git-ignored, to avoid polluting the git tree and commit history, especially on projects with many contributors.

✌️
Alright, that's it for today!
Thank you to Bitrise for sponsoring this issue ❤️
I'm curious if you found any of the tips particularly interesting - let me know by replying to this email!

Use the right assertions

Swift offers a number of ways to assert, i.e. stop the program, when something unexpected happens. Here's the gist of what to use when:

• Use assert() as often as you want, because it lets you check things are how you expect without having a performance impact in release mode, where the check is ignored
• Use the unconditional assertionFailure() if there’s somewhere your code shouldn’t reach, but it’s not a disaster if it happens.
• Use precondition() only when a check is critical to keep your user safe (app will crash). Same goes for fatalError().

Related, Combine's breakpointOnError() acts as a precondition and will stop (crash) the app in release builds too:

Read more on Hacking with Swift:

Understanding assertions – Hacking with Swift+

Assertions allow us to have Swift silently check the state of our program at runtime, but if you want to get them right you need to understand some intricacies. In this article I’ll walk you through the five ways we can make assertions in Swift, and provide clear advice on which to use and when.

Hacking with SwiftPaul Hudson twostraws

Private Set

Don't know who needs to hear this but here's a reminder that private(set) exists 🙂

Implementing reachability

The users won’t always have a good internet connection, so optimizing your app for bad networking conditions is essential.
Apple directly advises against checking for connection state, and recommends attempting to make a network call either way, and respond to a failure.
When you really need to know the state of the connection, use NWPathMonitor to observe conenctivity. It's available since iOS 12, so there's no need for a third party reachability library anymore.
Antoine covers more details in his new article:

Optimizing your app for Network Reachability

Optimize your app for Networking Connectivity and prevent common mistakes like pre-checking for reachability.

SwiftLeeAntoine van der Lee

@available attribute

My favorite use for the @available attribute is marking initWithCoder: methods, so they don't come up in autocomplete for the class:

final class MyView: UIView {

  @available(*, unavailable)
  required init?(coder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
  }
  
  init(customStuff: [Int]) {...}
}

There are other handy uses, such as marking your methods as deprecated - we don't have to provide the iOS version, and can just mark the method as "undesireable" for use:

@available(*, deprecated, message: "Use TheNewImplementation instead. OldImplementation will be deleted soon.")
class OldImplementation { ... }

Here's a short handy list of possible parameters to the @available attribite:

How to use the @available attribute in Swift

Swift provides the @available attribute which we can use to make our code only available for certain Swift language versions or platforms. Learn about the arguments unavailable, introduced, deprecated, obsoleted and more.

✌️
Alright, that's it for today!
Thank you to Bitrise for sponsoring this issue ❤️
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

Iterating over some elements

Here's how to iterate over only some elements in the array. Both options, for-case-let and for-in-if, are more efficient than filtering the array and iterating on the filtered results 🙌

Xcode 14.3 & Swift 5.8

There's a bunch of improvements available in the new Swift and Xcode. Here are a few things that caught my attention:

Implicit self

• Implicit self is now permitted for weak self captures, after self is unwrapped:

class ViewController {
  let button: Button

  func setup() {
      button.tapHandler = { [weak self] in
          guard let self else { return }
          dismiss() // refers to `self.dismiss()`
      }
  }

  func dismiss() { ... }
}

Debugging previews with print

• print output now appears in the console for SwiftUI Previews by selecting “Preview” tab in the console.

Previews in modular dependencies

• Fixed: Previews can fail when previewing a file inside of a Swift package target that is the dependency of an executable target.

Waiting for expectations

• The timeout argument of XCTestCase.wait(for:timeout:enforceOrder:) and related methods is now optional—if you don’t specify it, the function waits indefinitely (until the overall test times out.) To ensure reasonable execution time, set an appropriate value for the executionTimeAllowance property of the running XCTestCase instance (self).
• XCTestCase.wait(for:timeout:enforceOrder:) and related methods are now marked unavailable in concurrent Swift functions because they can cause a test to deadlock. Instead, you can use the new concurrency-safe XCTestCase.fulfillment(of:timeout:enforceOrder:) method.

Test plans

• Xcode now defaults to using a test plan for new projects. Learn more about test plans in the documentation: Improving code assessment by organizing tests into test plans

Read about everything new here (this links directly to the section about Swift but you can scroll up and down to read about all the changes in Xcode):

Xcode 14.3 Release Notes | Apple Developer Documentation

Update your apps to use new features, and test your apps against API changes.

Apple Developer Documentation

✌️
Alright, that's it for today.
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

Modern UIButton actions

With iOS 17 on the doorstep (yes, it's 3 months until WWDC), most projects have upgraded to newer minimum deployment targets. So it's a perfect time to remind about this lovely UIAction API for adding handlers to UIButtons - where we don't need to involve @objc #selectors anymore 🎉

Inline images in Text in SwiftUI

There's a lightweight way to insert images inside Text in SwiftUI - in string interpolation. If it's a custom image, it will be displayed in the original size. But if the image is an SF symbol, it will take on view modifiers applied to the Text - font, symbol variants, color, etc.

Deciphering Core Data error codes

CoreData produces nondescriptive errors such as  Domain=NSCocoaErrorDomain Code=1610 "The operation couldn't be completed. (Cocoa error 1610.) . There's a way to quickly check the meaning of the error code - by opening CoreDataErrors.h with Quick Open (just make sure to open the original and not the Swift interface). Alternatively, it's available online: CoreDataErrors.h as a gist on GitHub

Storyboards vs programmatic layout

When we talk about UIKit, programmatic layout has lots of benefits - easier code review, traceable changes via git, and code is a single-source-of-truth. But some teams prefer storyboards for their own reasons. In that case, here's an article with advice on how to improve quality of life when working with interface builder:

• understanding the XML structure
• what issues to look for during code review
• avoiding merge conflicts by locking against changes

Note: In the article the author mentions faster compilation time with storyboards vs programmatic layout. That can be true with lots and lots of layout code, but also the code structure itself affects compilation time, not only the amount of it. For example, if you use a global spacing constant, changing that one value can cause almost a full re-compile, while changing one storyboard file only recompiles that one file.

Why did we change our iOS rule to allow using Storyboard?

Our UI creation rule was creating a UI programmatically. But recently, we changed it.

99.coSungwook (Shawn) Baek

✌️
Alright, that's it for today! Thank you to RevenueCat for sponsoring this issue ❤️
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

Structuring unit tests

To prevent our complex unit tests from turning into a mush of hard-to-read code, we can annotate the tests using the Given-When-Then technique:

// Given
let mockStorage = Storage(value: "123")
let sut = Cache(storage: mockStorage)
// When
sut.clear()
// Then
XCTAssertEqual(mockStorage.value, nil)

This is a tiny example, but a real saver for more complex test scenarios.
Read more by Martin Fowler:

bliki: GivenWhenThen

a bliki entry for GivenWhenThen

martinfowler.comMartin Fowler

Don't change default params when subclassing

This unexpected behavior came as a total surprise for me - when we override a method with default parameters, sometimes the default parameters of the superclass's method will be used. So we should keep the default values the same in the override's method signature to avoid surprises and bugs.

An Unexpected Behavior of Subclasses in Swift

Don’t change default param’s values when subclassing

Better ProgrammingRiccardo Cipolleschi

Delegate naming conventions

The delegate pattern is familiar to iOS developers, but naming of the delegate methods can differ. A good practice is to include the sender parameter, and make it clear in the function name that it's a delegate method, so it stands out at the implementer side.
Read about good naming conventions for delegate methods by John Sundell:

Delegation in Swift | Swift by Sundell

The delegate pattern has long been very prominent on Apple’s platforms, and used for everything from handling table view events using UITableViewDelegate, to modifying cache behavior using NSCacheDelegate. This week, let’s take a look at a few ways to implement the delegate pattern, along with their…

Swift by Sundell

Fixing file header template for packages

Xcode still doesn't add proper filename, project name and copyright into new files created in SPM packages. Here's a short article explaining how to finally fix that:

Xcode Header Template for Swift Packages

If you use Swift Package, there are 2 pesky problems whenever you create a new file.

@samwize

Learn about SwiftUI view lifecycle

The demo project you didn't know you needed :)

GitHub - ole/swiftui-view-lifecycle: Observe how different SwiftUI container views affect state and lifecycle events (onAppear, onDisappear).

Observe how different SwiftUI container views affect state and lifecycle events (onAppear, onDisappear). - GitHub - ole/swiftui-view-lifecycle: Observe how different SwiftUI container views affect…

GitHubole

✌️
Alright, that's it for today! Thank you to RevenueCat for sponsoring this issue ❤️
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

Documenting hacks

How often do you add dispatch.async as a way to fix a bug? Hopefully not often! The core of solving a bug without causing more bugs, is understanding the root cause and fixing that.
But sometimes, even though we find the root cause, there's no way to address it, so a hacky workaround is necessary. In that case, make sure to add a detailed comment next to the hack. For your colleagues and your future self!

Two ways to mock in tests

Here's Manuel describing two ways to implement a loading view model and its tests. One employs protocols for dependency injecion, and another uses closures. The same example code is used in both approaches, so you can easily compare and pick your favorite. Beautiful and concise articles, with links to GitHub included.

Enhancing Testability with protocols

In the last post we’ve discussed hot to enhance testability without using protocols. In this one, we will build something similar but using protocols instead. We will be using dependency injection to be able to inject the real objects in the app, and inject mock objects in the tests / previews. We w…

The Product EngineerManuel Herrera

Enhancing Testability without protocols

We have all used protocols to enhance testability in our apps, but that can become too verbose, and add extra layers of abstractions to the code. Here is a different approach, without using protocols, that can achieve the same results with way less code. Let’s say we have a screen with a button that…

The Product EngineerManuel Herrera

Don't subclass URLCache

Few days ago I saw a post by Nikita on Mastodon asking if anyone could help him solve a bug with his URLCache subclass not actually caching anything. Some days later, he wrote a post with his findings.
Turns out, nowadays URLCache is not subclassable anymore, even though the documentation states that it is. Instead, we should build our custom caching logic above the url loading layer.

A path of pain with URLCache eviction and subclassing

URLCache class implements the caching of responses to URL load requests, by mapping NSURLRequest objects to CachedURLResponse objects. It provides a composite in-memory and on-disk cache, and lets you manipulate the sizes of both the in-memory and on-disk portions. You can also control the path wher…

Zhuk NotesNikita Zhuk

What's new in Swift - a refresher

Sometimes when new stuff is released in Swift or the SDK, it gets forgotten because you can't use it right away. Swift versions is one of those things - they are released even before Xcode is.
So here's a refresher on the lovely Swift features we can now introduce in our projects on Xcode 14+ - the shorthand if let, new regex syntax, and more. Available in video and article format:

Discover some New Features of Swift 5.7 — Swift with Vincent

You’re more of a video kind of person? I’ve got you covered! Here’s a video with the same content than this article 🍿

Swift with VincentVincent Pradeilles

Merge when ready on GitHub

Are you working in a repo where you have to wait for CI to finish before merging a pull request? Then GitHub's new merge queues feature is going to improve your day-to-day :)

Before merge queues, developers were often required to update their pull request branches prior to merging to ensure their changes wouldn't break the main branch when merged. Each update resulted in a fresh round of continuous integration (CI) checks that would have to finish before the developer could attempt to merge. If another pull request got merged, every developer would have to go through the process again.

Even if you're not needing the queue part, the "Merge when ready" button is the feature I've been missing all along.

Pull request merge queue (public beta) | GitHub Changelog

Pull request merge queue (public beta)

The GitHub Blog

✌️
Alright, that's it for today! Thank you to RevenueCat for sponsoring this issue ❤️
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

By the way, next issue will arrive on Tuesday, February 14th 💌

Speeding app launch by improving code

A story about DoorDash improving their app launch time by auditing and improving code that's run during startup. Among other things, I was surprised how small changes make a big difference. For example, shifting from using String(describing:) to ObjectIdentifier boosted their launch time by 11%!

How We Reduced Our iOS App Launch Time by 60%

Learn how DoorDash went about optimizing our customers’ experience and making continuous improvements in app launch times

DoorDash Engineering BlogFilip Busic

Optimizing code performance

In this article you'll learn about even more small tweaks you can make to Swift code that would optimize for performance. I love how Avi includes the "price table" - the tradeoffs for each of the suggestions 👍

9 Ways to Boost Your Swift Code Performance

Some tips on squeezing Swift for speed

Better ProgrammingAvi Tsadok

Improving linting speed

Many of us use SwiftLint, and if you don't - it's a good idea to add it to the project.
Xcode 14 introduced a new warning, notifying us of a previously non-obvious fact - with the default setup, SwiftLint is ran on all source files in the project, even for incremental builds, when only one file was changed, for example.
So the incremental builds are slower than they could be - and on large projects this could be a noticeable difference.

So what can we do? If we just accept Xcode's suggestion, it will just silence the warning. Gladly the warning is useful here - it hints that we can configure it to work together with incremental builds, so it would only run on files that changed.  

Steven here made a detailed write-up on how to configure this in Xcode, so you get faster incremental builds:

GitHub - steven851007/SwiftLint_build_phase_example

Contribute to steven851007/SwiftLint_build_phase_example development by creating an account on GitHub.

GitHubsteven851007

Formatting JSON strings

A small reminder that we can write JSON strings rich with quotation marks without escaping them - keeping the readability of the JSON.

On testing

It's not the first time I share one of Jason's thoughts. I find most of what he writes extremely insightful. If you're still on Twitter, make sure to give him a follow!

✌️
Alright, that's it for today! Thank you to Paste for sponsoring this issue (and here's their iOS/macOS developer job posting).
I'm curious if you found one of the tips particularly interesting - let me know by replying to this email!

My favorite architecture

Here's my favorite architecture stack for UIKit apps. I'm planning to write more about the different aspects of it - got a few questions in the comments there. What would you like to hear about first? (let me know by replying to this email)

VStack, LazyVStack vs List

Here Pitt compares the performance of the three options, on a real app. Excellent explanation of the differences, and tl;dr - never use VStack for lists with many elements.

In case you need to implement a long list with infinite scrolling, here's Donny summarizing how to achieve it with LazyVStack and List:

Implementing an infinite scrolling list with SwiftUI and Combine

Learn how to use SwiftUI’s onAppear and Combine to build a List that scrolls forever. As a bonus, you’ll also see how you can achieve the same with a LazyVStack.

Donny Wals

On technical debt

Loving the analogies with the financial world. Technical debt is like actual debt, we borrow to be able to afford something we otherwise can't. Improving or cleaning up code is like an investment - we spend time to get something in return later.

Unwrapping optionals

Three ways to unwrap an optional, shaped as a meme:

Is this good code?

My galaxy-brain answer to this would be: as long as this function is covered by extensive unit tests, it doesn't matter that much how it's implemented.

✌️
Alright, that's it for today! Thank you to Coduo for sponsoring this issue.
I'm curious if you found one of the tips particulary interesting - let me know by replying to this email!

Ordered dictionary anyone?

Did you know that Swift has an official package with ordered versions of our well-known data structures: OrderedDictionary and OrderedSet? They live in a separate SPM package because the Swift core team decided that such components should live in separate packages until they are deemed worthy of inclusion in the standard library.

GitHub - apple/swift-collections: Commonly used data structures for Swift

Commonly used data structures for Swift. Contribute to apple/swift-collections development by creating an account on GitHub.

GitHubapple

OrderedDictionary In Swift

Learn how and when to use OrderedDictionary, provided by the swift-collections package, in Swift.

Advanced SwiftRobert Pieta

Using Label in SwiftUI

Whenever we want to show an icon and text together, Label comes to the rescue. It supports accessibility out of the box, and offers the ability to easily hide the icon or text using the modifier .labelStyle(.iconOnly) , while preserving the accessibility information.

SwiftUI Label: A standard way to label user interface items | Sarunw

A label might seem trivial, but it plays an important role in SwiftUI. Let’s learn about this simple view.

Sarunw

Accessibility of images in SwiftUI

On a related note, we can enrich images with accessibility text in another way - by simply providing a localizable string with the image name as a key. It works out of the box, with no additional modifiers needed on the image 😍

Image accessibility labels from Localizable.strings files

When we add an image name to a Localizable.strings file, SwiftUI automatically uses it for the image accessibility label.

Nil CoalescingNatalia Panferova

Better XCTest failure messages

When we use XCTAssertNil(sut.optionalProperty), the failure message in case of assert failing will be not so helpful - "XCTAssertNil failed". By using XCTAssertEqual(sut.optionalProperty, nil) instead, we will get the actual value of the property in the failure message.
A few more suggestions on asserting optionals better, shared by Jon Reid:

How to Unit Test Optionals in Swift | Quality Coding

You have a Swift optional value. How can you write an XCTest assertion to verify it, while getting the most from assertion failure messages?

Quality CodingJon Reid

Accessing view controller's view

UIViewController's view is lazy, created the first time .view is accessed. When we want to access it without triggering the lazy creation, only getting the view if it already exists - there's viewIfLoaded property. Available since 2015, shared by Peter in 2019, and I saw this yesterday, in 2023 😅

✌️
Alright, that's it for today! Thank you to dataTile for Simulator for sponsoring this issue.
I'm curious if you found one of the tips particulary interesting - let me know by replying to this email!

Supporting webp images with PHPicker

Are  you using PHPickerViewController for photo library imports, and access images using loadObject(ofClass:)? It turns out, this method doesn't support some image formats, such as webp images. You can use loadDataRepresentation(forTypeIdentifier: "public.image", completionHandler:) instead.

Equality vs Identity

How is === different from == ?=== checks if it's the same instance, and is available only for classes. But why do we almost never have to use it?

All NSObjects ( UIView , UIViewControllers, etc) get a default Equatable conformance that uses Objective-C's isEqual: , which in turn compares instances, like === would. So when writing checks like if sender == myButton, we actually mean ===, but can save one character thanks to Swift's interoperability with Objective-C.

More formatter coolness

I can't stop being amazed by all the different features available in formatters out of the box:

Readable large numbers

We can arbitrarily add _'s inside any type of number literal - integers, floats or even hex numbers:

large number separators — Swift with Vincent

Here’s the code if you want to experiment with it!

Swift with VincentVincent Pradeilles

My top 5 tips

I teamed up with Vincent to record a 20 min. video where I share my top tips to improve your Swift code. Some of them have been featured in the newsletter earlier, but some have not:

• Avoiding Retain Cycles with Combine or RxSwift
• Typesafe Identifiers
• Managing Complex UI States
• Never Forget to Call a Completion Handler
• Simplifying UI Code with Layout Margins
• Typesafe Strings and Images

If you haven't seen the video yet, do check it out ☺️

✌️
Alright, that's it for today! Thank you to Codelime for sponsoring this issue.
I'm curious if you found one of the tips particulary interesting - let me know by replying to this email!

Happy holidays 🕎🎄

Modern collection views

A lot has changed in UITableView and UICollectionView APIs in the recent years. While before we would subclass UICollectionViewCell and implement UICollectionViewDataSource and UICollectionViewDelegate protocols, the modern ways look nothing like that.

Now we provide cell content using cell configurations, dequeue reusable cells using cell and supplementary registrations, use diffable data sources for safe data with animatable updates, and use compositional layouts for grids, lists and carousels. All of this is available iOS 14+.

Apple has comprehensive articles with explanations and sample code, going over these concepts and showing how they play together:

Implementing Modern Collection Views
Implementing Custom Cells Using Content Views

xcconfig files

Xcconfig files are considered an advanced feature, only reserved for larger projects. That's my impression, at least. But the idea is quite simple - we can override build settings of a target via plain text files.

When we have multiple targets with mostly same build settings, it's better to use xcconfig files for specifying the parameters that are different - the contents of .xcodeproj files are not easily trackable in source control, and using xcconfig files solves that.

How to manage build settings using Xcode configuration files | Danijela’s blog

You use Xcode build configuration files to define all sorts of useful build settings. You can open them with different text editors outside of Xcode and all properties are in plain text. It’s common to use them for managing constants across different environments.

Danijela's blog

Custom screenshot support

TIL about UIScreenshotServiceDelegate - allowing you to support custom PDF export via the native screenshot functionality. To see it an action, try taking a screenshot in Safari - there will be a segment control at the top, choosing between just the screenshot or a PDF of the whole page.

When the user captures a screenshot of your app’s windows, UIKit calls the methods of this protocol to retrieve PDF data for those windows, and then it provides that data to the user.

Dummy data for previews

To reduce app size and memory footprint of your app, make sure that the test data for SwiftUI previews is not included in release builds. You can wrap the code to exclude in #if DEBUG.
Another option is to use "development assets" - a relatively new build setting in Xcode. You can specify which files (code or assets) will be stripped during release builds. Read more: Development Assets in Xcode to enrich SwiftUI Previews

Coding is like gardening

A wonderful analogy, indeed the code is not built once and done, but grows and evolves over time. I'm a big proponent of building code in a way that welcomes future changes.

✌️
Alright, that's it for today.
Thank you to TelemetryDeck for sponsoring this issue!

Apologies for sending this issue a day late - I've had a small self-inflicted injury and had to go to the hospital just in case. All is well in the end though 😊

You might have noticed a different sender and layout this time - that's because I've switched from Revue to a content platform called Ghost. It's a really powerful platform, and I will be expanding the site, such as adding the ability to search among all past issues. Stay tuned :)

Structuring SwiftUI views

SwiftUI is relatively new, but there are other declarative UI languages with history. React is a popular web frontend framework, and there's a lot we can learn from there.
One example is a pattern where we break down views that load data into two:
The outer view is a loading component that's aware of the networking, and the inner view is a more "stupid" view with just UI elements.
The inner view then can then be reused - across features, for previews in app settings, and for SwiftUI previews.

Organizing test image assets

Good tip here to avoid cluttering your app with images you only use for testing - saving on both app size and compile time:

Project quality-of-life

Completely agree with the list here. When there's no warnings in the project, the console log isn't cluttered, etc - it's so much easier to spot new issues right when they are introduced:

URLRequest cache policies

Excellent article to understand the various cache policies and how they affect your iOS application when sending HTTP requests with URLRequest:

Understanding different cache policies when working with URLRequest in Swift

Learn how to manage cache when sending HTTP requests in your iOS applications. Learn about the differences between the policies useProtocolCachePolicy, reloadIgnoringLocalCacheData, reloadIgnoringLocalAndRemoteCacheData and more.

Xcode power tips

If you want to become more efficient with Xcode, watch this 17-minute video. I've been using Xcode for over a decade, and I learned so much. The more efficient we are, the more time we have to actually focus on problemsolving and code ☺️

🤘

Alright, that’s it for today.

If you enjoyed this issue, you can help grow the newsletter by spreading the word!

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Yesterday I've sent out the issue #35, and it was flagged as spam by Gmail. It was due to technical problems on Revue side, not sure what exactly. They got fixed after I reached out to support, and now the emails are delivered ok.

I know that a lot of you are looking forward to receiving the newsletter, but I didn't want to just redeliver the same email again. Hence this bonus issue with two great articles 😊

If you're on gmail, check your spam folder for the previous email, and please mark it as "not spam" 🙏 If you're not on Gmail, I hope you don't mind the bonus issue 💚

I am investigating changing to a more reliable email platform, so the email layout might be slightly different next time.

Managing secrets

How do we store secrets securely on the client? This NSHipster article goes over the pros and cons of hardcoding values in code, using xcconfig files, or providing API keys over the network.

Secret Management on iOS - NSHipster

Writing a perfect pull request

When you make a good pull request, you receive a quick review, clear feedback, and don't get too many questions such as "why did you do it like this?". This usually has almost nothing to do with the actual code changes! In this article you'll find tips on how to make your pull requests great.

How To Write The PERFECT Pull Request  | Level Up Coding

🤘

Thank you for bearing with me, and see you in two weeks!

Welcome to the issue #35 👋 Enjoy!

Better test assertions

We all want the tests to immediately tell us that something is wrong, and here's some advice on how to achieve that by using XCTAssertEqual instead of just XCTAssert:

Multiple accessibility labels

With accessibilityUserInputLabels, we can provide multiple strings by which the user can address an element.

And a reminder not to use accessibilityLabel for internal strings for UI tests, there's accessibilityIdentifier for that.

System background

Reminder that UIColor.systemGroupedBackground exists, reflecting system background you see on grouped table views, for example in Settings. We can use it in both UIKit and SwiftUI:

More formatters

Remember ListFormatter I mentioned last time? Here's an infographic with even more examples of different native formatter APIs.

The traps of Swift Concurrency

There's many things the compiler doesn't check, and often the behaviour of async/await is not what you'd expect. Lots of traps to fall into... For example, actors are not as protective as they seem at first glance. Many examples of problems and solutions in this article by @kulik_wojciech.

It's a longer article going deep into how concurrency works, make sure to save it if you don't have time to read it yet :)

Swift Concurrency – Things They Don’t Tell You

Sponsor of the week - Codelime

Codelime is a powerful code snippet manager with many dev tools for iOS development. Save and manage your code snippet across iPhone, iPad and Mac with Codelime.

Take advantages of many dev tools available in Codelime (Hash, Text Case, Color Picker, Generate Asset Catalog, Make Pretty Code Snippet, ...) to boost your every day iOS development workflow.

The app is made by 2 indie developers Khoa 🔥 and Kenny 🌴

Codelime - Powerful code snippet manager

Powerful code snippet manager

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Welcome to issue #34 👋 Hope you learn something new today!

I also got the first sponsor this time - I'm really excited to be able to get some funds to continue growing the newsletter! I'm already investing them into improving my curation workflow and building a custom landing page. If you're looking for a job, check out the sponsored section at the end ☺️

Organising package manifests

Package.swift is a Swift file, and that means we can write Swift code in it, for example declare variables and functions, and even call them.

Are you already using any Swift language features in your package manifest? I'm curious about what other use-cases we can find for this.

Localised lists

ListFormatter composes a localised string from an array of elements, using a grammatically correct way to join the strings for the current locale. You can also customise how each element in the list is formatted by providing an itemFormatter property.

Year formatting

Every year it comes up on Twitter around December 30, that using YYYY in date formats is incorrect for displaying dates, as it stands for "week year" which will be wrong around the New Years week.

This year it's not yet too late to make a fix, so here's a reminder to check your code :)

Accessibility customisations in SwifUI vs UIKit

It's not always clear how to achieve the same accessibility customizations in SwiftUI vs UIKit. Here's a great summary - make sure to save it to your bookmarks for later:

Accessibility in SwiftUI explained for UIKit developers - SwiftLee

Accessibility in SwiftUI works a little different than in UIKit, but with a few tips you'll be able to get up to speed quickly.

SwiftUI performance tips

In this article Martin goes over various aspects of SwiftUI development and shares solid advice on avoiding performance issues in your UI code:

SwiftUI performance tips – martinmitrevski

SwiftUI has been around for almost 3 years now, and during this period working with it, I’ve noticed few groups of developer mistakes (both mine and from others) that can impact its performance. In this post, we will look at these pitfalls, and their potential solutions.

🧑‍💻 Sponsored Jobs 🧑‍💻

My friends at Shape Games are looking for iOS developers:

• iOS developer (remote)
• iOS developer (relocation to Copenhagen)
• Student iOS developer

They’re building the leading sports betting frontend platform. This posting was sponsored (yay!), but also I personally know many people working there, and I've been to their lovely office for meetups countless times. It’s a great mobile team who care about the craft 👍

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Welcome to the 33rd issue 👋 We're back to a classic five-tips structure, and I hope you find something interesting today.

As an innovation, I've included a new section at the bottom with featured jobs. They're not sponsored this time, but I hope to get sponsored job or indie app ads in the future. The code tips themselves will never have any promoted content in them, only what I truly think is best ☺️

Traversing the view hierarchy

Iterating over superview chain, or parent view controllers, you name it. Awesome trick to replace recursive lookups.

Have you heard of sequence(first:next) ? It's a Sequence (the same protocol arrays, dictionaries, and other collections conform to), and can be used with for...in , forEach, map, etc.

sequence(first:next) generates an iteratable sequence on the fly, each next element being derived from the previous one. As soon as next returns nil, iteration stops. So the next closure can return nil, but elements in the sequence are non-optional. If nil is never returned, the sequence is infinite.

For example, here's an infinite iteration over even numbers:

for i in sequence(first: 0, next: { $0 + 2 }) { print(i) }

A super neat application for this is to iterate over the view hierarchy, or view controller hierarchy, you name it:

Completion handlers

I really like how we can use typealiases for completion handlers to make code easier to read and refactor:

func do(completion: @escaping ((Result<X, Error>) -> Void)?)

becomes

func do(completion: @escaping CompletionHandler<X>?)

Better TODO warnings

If you're using warnings as TODO reminders, they might be mixing up with real warnings from the compiler. A little productivity tip: adding an emoji to the warnings, and using code snippets makes leaving and viewing TODO-warnings much nicer.

Refactoring a complex View

A short story on refactoring a complex SwiftUI view into smaller views that share the same view model instance. It's a nice approach to making the UI code more maintainable, and even testable.

Efficiently Develop Cleaner SwiftUI Views Using A View Model

Learn how to quickly develop cleaner views by using a view model.

Initialization in Swift

I learned Swift over the course of one summer, and this chapter on Initialization was what stuck with me the most.

Initialization is something we don't think too much about - you write your init method(s) and then if the compiler is not happy, do whatever Xcode suggests to fix it. But in reality, there are carefully thought-out rules and reasons behind restrictions being the way they are.

If you want to learn more about Swift itself, this is a nice read over a cup of something warm 🍁

Initialization — The Swift Programming Language (Swift 5.7)

Initialization is the process of preparing an instance of a class, structure, or enumeration for use.

🧑‍💻 Featured jobs

Proton (the company behind ProtonMail) has four open iOS positions: iOS (VPN), iOS (Drive), Senior iOS (new product), Engineering Manager (Core iOS). All are available remote and in-office.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Hope you're doing good and working toward your goals, whatever they are (whether that's work, resting more, spending more time with family, or protecting what's yours).

Today I have a couple of longer sections - hope you enjoy the read, and I'm always curious to hear your thoughts!

Let's dive in 👇👇

Is it SwiftUI's fault?

In the last couple of months there's been a lot of discourse on Twitter about the betas and the first public versions iOS 16/macOS 13. Some blame the rawness of the first versions specifically on SwiftUI and its immaturity, and this gets reverberated by others. Is it correct or even fair to blame incompleteness of features or bugs on one framework, disregarding other context such as processes, quality of QA, or time constraints?

I won't share the negative takes not to point fingers (I also don't have that many fingers 😂). Here's a few other takes on this, with a bonus positivity thread in the end. Tell me what you think!

Swift 5.7 is here!

If you've already upgraded to Xcode 14, that means you can take advantage of improvements in Swift 5.7.

I might cover more individual features in the future, but in the meantime you can check out the official overview and the full list of evolution proposals released in 5.7.

Here's a thread about improvements to generics and protocols:

On the practical side of things, here's a regex to replace all if let x = x { with the new shorthand if let x {:

Compiler errors ftw

Truth. Linters are also nice :)

Directory of Apple frameworks

A full directory of all Apple frameworks with ability to filter by platform and minimal supported version 💪

🤘☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Also I’d love to hear from you. Just reply to this email or DM at @ios_code_review 👋

Did you enjoy the Apple event yesterday? Whether you're into the latest tech, or in the camp of anti-consumerism, hope you had a nice day 🙂

On Twitter it might seem that everyone is so excited about the new phones/watches/etc. But that's just the bubble. I, for one, will not be buying a new iPhone or watch any time soon - will keep enjoying my 2-year-old XS and series 5. To whomever needs to hear this, it's totally ok not to jump on buying the newest thing, but also it's ok to do so.

Now let's dive in, hope you learn something new today

On [weak] self (again)

The weak self subject is a bit worn, but check this out. Steve has a good general point that such everyday things should be as ergonomic and effortless as possible in a language.

Here Steve also shared an article on the topic of self in closures. It's sort-of-a-reply to another opinionated piece, but I really like it on its own. If you were looking for once-and-for-all answer to the question of when to use weak and when not, this might be it.

I promise no more weak-self related tips 😀

The Golden Rules of weak self | Chris Downie

Capturing self in a closure is a common thing to do in Swift, and one that hides a lot of nuance. Do you need to make it weak to avoid a reference cycle? Is making it weak all the time a problem?

Thoughts on massive observable objects

Having granular ObservableObject's is a good way to go. To avoid unnecessary re-renders, give the high-level views only the dependencies they need.

Actions in @Environment

Very important TIL-moment if you're embracing @Environment-based action closures such as OpenURLAction. They should be callable types, not closures - otherwise views that use this variable will re-render unnecessarily whenever the environment could change - for example, on rotation or going to foreground.

Callable structs look like functions to the user of the api, as if you used a typealias for the closure type. If you define a type (struct, enum or class) and add a function named func callAsFuntion() , you'll then be able to invoke it by using () - x() is equivalent to x.callAsFunction(). This supports custom parameters too. It's a pretty cool feature in Swift!

Slack's legacy codebase improvement story

Recently Slack shared how they improve their legacy mobile codebase in a 3-article series. Here's an 8-minute summary, in case you don't have 30+ minutes to read the original, which is also linked there.

Mobile App Refactoring Initiative by Slack | by Elye

A summary of how Slack stabilized, modularized, and modernized its mobile application code base

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

I hope the summer is treating you well, and you're progressing toward your goal, whatever it is!

As promised in the last issue, here's me sharing behind-the-scenes on how I make the newsletter issues: https://youtu.be/CgTqqkzeeh8

Let's dive in 👇

On push notifications

Last week Airbnb accidentally sent a test push notification to real users. Sarun has a good point - it's not a good idea to use inappropriate words in text that could be seen by users. This applies to everything - not just push text, but also in code that shouldn't theoretically be executed in non-debug builds.

The sum effort

This simple formula Jane shared really put things in perspective for me.

Also it brought me to realise: if someone put effort into making the code more readable and well-structured, then it's less effort to read / work with later. If someone wrote "bad code" - perhaps spent less effort writing it - it takes extra effort to read later. Either way, the sum of total effort can be the same. No easy way out, the effort has to be spent by someone at some point, always.

Better equality test failures

If you've ever seen a test failure like this and hated it, Difference is a package that can help. It offers a diff function that returns a readable explanation of what exactly is different. The doc for the library includes examples of how to easily use this with XCTest, Quick, and Composable Architecture.

GitHub - krzysztofzablocki/Difference

Simple way to identify what is different between 2 instances of any type. Must have for TDD.

REST API

If you ever wondered what's the difference between just API and REST API, here's a short, digestible writeup about it:

On code duplication

The problem of duplication is more nuanced than it seems. Common advice such as "duplication is cheaper than the wrong abstraction" is often based on the simplified view of the problem, that it's just about code.  In this article @JasonSwett looks at what duplication actually is, why it’s such a surprisingly complicated problem, and what can be done to address it. Thanks @ctietze for sharing the post!

We could imagine that duplication could be defined as a piece of code that appears in two or more places. Indeed, this sounds like a very reasonable and accurate definition. But it’s actually wrong!

Duplication is when there’s a single behavior that’s specified in two or more places

Duplication - Code with Jason

In this post I’ll show what duplication is, why it’s such a surprisingly complicated problem, and what can be done to address it.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

As I'm writing this, I am recording a show-and-tell video sharing a bit about my process creating this newsletter. I'll share it on Twitter and in the next issue, so stay tuned :)

I hope you find something interesting in my collection today 👇

Implicit weak self is coming

Usually I don't share things that Cannot Be Used Yet, but this one got me really excited! Starting with a future version of Swift, we won't have to write self inside closures after capturing it weakly:

swift-evolution/0365-implicit-self-weak-capture.md · apple/swift-evolution · GitHub

As of SE-0269, implicit self is permitted in closures when self is written explicitly in the capture list. We should extend this support to weak self captures, and permit implicit self as long as self has been unwrapped.

The background modifier

In the past year the family of  .background(...) modifiers has evolved. Now it has a few versions, allowing to customise alignment, safe area ignoring behaviour, and shape style of the background. There's even a version without any parameters at all - it sets the background to a color fitting the current color scheme. All versions are listed here and are documented pretty well.

Testing the mocks

Stumbled onto a peculiar use-case for unit tests, and I've never seen it in real-life projects. Documenting mock behaviour via tests will often be seen as "too much", but it can come handy in cases when lots of tests rely on one mock.

Thread safety in Swift

A longer but worthy read about different ways to manage multithreading in Swift and their trade-offs.

Thread Safety in Swift

Concurrency is the entry point for the most complicated and bizarre bugs a programmer will ever experience. In this article, I'll share my favorite methods of ensuring thread safety, as well as analyzing the performance of the different mechanisms.

Starting with open source

If you want to contribute to a project but didn't know which one, here's a good collection:

🤘☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

I hope you find something useful or interesting in today's collection ✨

Live-updating cells

Starting with iOS 15, there's a set of reconfigure methods that let you update a cell that's already on-screen. This allows us to make nice animations to views inside cells, which are not possible with reloadData - as it recreates cells from scratch.

In earlier iOS versions it was also possible to update existing cells, by getting on-screen cells with UITableView.cellForRow(at:) and updating the state manually. reconfigure can do that with less friction, and it can also update the height of the cell.

Check out Tyler's thread for a deeper dive into the new methods:

Approaches to mocking

Using the factory pattern is a common approach to mocking, but with Swift there are simpler approaches that work just as well: such as injecting values, injecting behaviour as closures (as opposed to injecting instances that perform a behaviour), or having factory methods as closures (as opposed to factory classes). In this thread Nick goes into different ways one can mock behaviour or values:

TL;DR:

On code readability

One comment from Nick's thread stood out to me - it really highlights the two extremes of code architecture: "hardcode everything" => no flexibility, changing one thing breaks other places; vs "mock everything" = code is not discoverable, no transparency in what to change code to achieve the goal. Balance is somewhere in the middle.

Technical debt is debt

Sometimes we say "there should be no technical debt". It's a really good aspiration, we've all been there. But as in life, going into debt can be beneficial:

but also:

Testing Codable initializers

A well-structured and understandable article on unit-testing custom Codable initializers. Lots of little gems in there - for one, the Difference library looks like a huge quality-of-life improvements for unit tests.

How to test custom Codable initializer | Danijela's blog

Sometimes, when parsing a JSON, you need to implement a custom Codable initializer. Because of that custom logic, you're no longer using the default implementation. It's a good idea to test your code.

🤘☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below. If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

It's getting harder and harder to not share cool things from iOS 16 (that we can't yet use). I'm managing to resist so far. Hope you find something interesting and useful in today's collection!

By the way, if you enjoy reading the newsletter - send it to a colleague ☺️

Using unsafe pointers safely

Unsafe pointers and bytes are only "safe" to use inside the body closure. From withUnsafeMutablePointer documentation: The pointer argument is valid only for the duration of the function’s execution.

DRY, evolved

Check out this thread about SPOT - Single Point Of Truth principle. It's similar to DRY (Don't Repeat Yourself), but better. I've been looking at code this way as long as I remember - I had no idea this way of thinking had its own name.

This comment perfectly points out the difference between SPOT and DRY:

Beautiful rounded corners

Are you using cornerRadius for rounding corners? There's a better way - .clipShape as a RoundedRectangle with continuous style in SwiftUI produces a smoother looking result. To achieve the same in UIKit, do button.layer.cornerCurve = .continuous .

Check this thread for comparison and SwiftUI code:

CloudKit

In issue #21 I shared an article about CloudKit being a red flag for indie developers. The biggest issue named was the inability to transfer the app to another developer account, if a CloudKit entitlement was ever used in the app.

That restriction is now gone - now apps that use iCloud can be transferred to another developer account 🎉

Here's the updated list of criteria for app transfer: App Transfer Criteria

App Store Connect Update - Releases - Apple Developer

Apps that use iCloud can now be transferred to another developer in the Apple Developer Program.

Non-optional Core Data attributes in Swift

There is a distinction between the concept of optional and non-optional values in Swift and Core Data. In Swift, you get compile-time guarantees, but in Core Data, the framework is enforcing the model rules in run-time. Optional Core Data attributes should be optional properties in Swift, but what about non-optional attributes?

In this article Jesse shares a robust approach to handling the differences and making sure the app doesn't crash.

How to more gracefully handle non-optional Core Data properties in Swift · Jesse Squires

🤘☀️☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below! If you enjoyed it, you can help grow the newsletter by spreading the word ☺️

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you - just reply to this email 👋

Every time I sit down to write an intro to an issue, I struggle between staying positive and the desire to address current events in the outside world. And every time I land on the decision to let this newsletter be a small island on the internet dedicated to learning something new in the field we're passionate about.

If you are affected by war, the pandemic, or any of the other struggles in our crazy world - know that I think of you every time I write this 💛

And thanks to all of you for being loyal readers! Seeing the high open rates and receiving your feedback keeps my heart warm(-er) ☺️

So I hope you find something interesting in today's collection. Let's dive in?

Accessible custom tab bars

.tabBar accessibility trait is almost magical when it comes to making a custom tab bar view behave like a system one.

If you want to learn more about this, Bas Broek wrote a detailed article on implementing accessible custom tab bars:

Building an Accessible Custom Tab Bar | Bas’ Blog

Recently, I’ve been working on making a custom tab bar in our app accessible. That is, make it work just like a native, out-of-the-box UITabBarController.

Interactive image preview transition

This is so cool. I didn't even realize that QuickLook framework can be used on iOS! Check out this short thread by Jordan:

Sink

Building safe APIs

The whole Swift language is built upon safety principles, so it only makes sense to apply them to our own APIs:

NSPersistentCloudKitContainer trickiness

A comprehensive write up about the realities of using Core Data with CloudKit syncing. The article is a few months old, and just now it's been updated with new findings. So if you've seen it before - it's worth checking out again.

General Findings About NSPersistentCloudKitContainer

This article contains our findings when converting Streaks to use NSPersistentCloudKitContainer.

🤘☮️

Alright, that’s it for today.

What do you think about me writing the comment above the tweet or link? Does it work? Or do you think it should be after? I'm curious to hear what you think. Let me know by replying to this email :)

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter 🙌

Hope you had a wonderful WWDC week! I myself have been on vacation (and still am), and only checked out the keynote and saw some tweets from the community.

Other newsletters have featured lots of WWDC-related articles - for example I loved the latest iOS Dev Weekly which was 100% about WWDC.

I tend to forget all the new things by the time I can use them for real, so I'll be featuring more of the new APIs after Xcode 14 ships in September. My goal has always been to share things that can be used right away in real projects (gotta be honest it's also convenient because I could continue spending the vacation offline 😋)

I was also interviewed on the AppForce1 podcast, where I shared a bit about how I make the newsletter ☺️

Now let's dive in!

#unavailable attribute

The new #unavailable attribute has been added in Swift 5.6 (Xcode 13.3) - we can now check for older OS versions directly:

if #unavailable(iOS 15.0) { /* this code will run on iOS 14 and below */ }

Dealing with SwiftUI type inference

Do you sometimes try to write f.ex. Color.background, only to have nothing come up in autocomplete? The issue is that .background exists, just not on Color - it's a separate shape style, and the shorthand is only available by the magic of type inference. Jérôme here shares an approach for finding what you're looking for (see series of pictures in the full tweet)

Unit tests eh?

in all seriousness though:

The new thing is out

Eternal wisdom from Jordan, now more relevant than ever before:

Moving the cursor in terminal

Okay this is not a code thing per se, but this terminal key binding has been a nice time saver for me since I learned it a couple of years ago:

🤘☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

As promised, today's issue is a special one, and I'm really excited to bring it to you. I wanted to spice things up a bit and invite a guest curator to create this issue. Because why not?

Say hi to Bas Broek - he will be curating the collection today. Bas had been authoring Swift Weekly Brief (sadly discontinued) for 2 years before joining the accessibility team at Apple. Now he's back to the community and shares his favourite bits of wisdom with us below 👇 😌

--------------------

This is Bas; I'm a friend of Marina's. As she reached out to me asking if I'd be up for writing an issue, I immediately said yes!

Having curated a newsletter before, I know it can be quite a bit of work; having the community help out was always a highlight of writing the newsletter, so I'm always happy to return that favor.

Enjoy!

Accessibility hints

This thread is not about the literal API, but rather a bunch of things that are good to know and be aware of when building accessible products. I would love to know — how do you review code for accessibility?

Speaking of accessibility hints, here's Dani sharing an insight every day for the WHOLE YEAR. So great to see this topic being put in the spotlight. Check out his twitter and/or follow him for the daily accessibility tips.

Attributed Strings

As Marina mentioned in the last newsletter, it seems she's not the only one excited to see Natalia being back to blogging. Before she joined the SwiftUI team at Apple, her blog posts were a fresh breeze with amazing insights. Now, after leaving Apple, she's back to it, taking all the experience from her time at Apple with her — and it shows.

The new AttributedString API is type-safe and powerful, and can be used not only in SwiftUI, but also with UIKit and AppKit. The type-inference going on is quite complex though. Check out the full article offering a deeper understanding on configuring the new attributed strings: AttributedString Attribute Scopes

Equal sizing in SwiftUI

In this short article Matthias shares a clean approach to making all elements in a VStack as wide as the widest element (but not take up the entire proposed width):

SwiftUI equal and ideal sizes

One of the more common sentiments towards SwiftUI you’ll come across on the Internet goes something like this: It’s magical until it isn’t. Meaning: SwiftUI let’s you write UI code so quickly that it sometimes feels like a superpower. But suddenly you hit a wall and there’s seemingly no way around it. One example that illustrates this quite well is when you want to make all children of a VStack as wide as the widest child. Sounds like it should be straightforward. But it’s not. It’s a surprisingly hard problem.

Beyond code

Paris shares an insight on something we may overlook; sometimes it's not only about code.

WWDC Preparation

Here's a couple of helpful tips on preparing for WWDC, when it comes to audits and labs:

Thanks for reading! Enjoy WWDC next week, and see you around!

- Bas

--------------------

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below.

Do you want to see other guest curators on the newsletter? Tell me who you'd like to hear from by replying to this email 🙌

WWDC is coming soon, are you excited? I am, but also looking forward to some vacation time. Not sure yet how much of catching up with the freshest-and-greatest content I'll do in June, but either way there will be some interesting stuff to share.

Also stay tuned for the next issue #24 on June 1st, it will be a very special one 🤩

Now, let's dive in 👇

Sizing of SF Symbols

Great thread, nothing to add 😌 Excited to see that Natalia is back to blogging. She posts interesting content regularly, I wish I could feature all of it! Make sure to follow her on Twitter.

Automating the encryption compliance check

Definitely makes the life easier. For additional instructions check  Complying with Encryption Export Regulations

Comparing date ranges

Since overlaps(_:) is declared on Range and ClosedRange, it can be useful not only for dates, along with contains(_:) (also found as the  ~= operator). One can almost forget about comparison operators 😀

On dependency injection

Some food for thought on the topic of injecting / resolving dependencies. In this Twitter thread you'll find interesting points for and against various approaches 👇

Starting with unit testing

I wrote a guide to help developers who are motivated to start unit testing their code, but are uncertain about where to begin in practice. Among other things, you'll find some approaches to picking what to test, and how to start testing seemingly untestable code.

Unit testing: The pragmatic guide on where to start | Marina Gornostaeva

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Hope you enjoy today's collection 🙌

Updating @State values

It's not safe to update @State properties from any callbacks except those provided by the SwiftUI framework. Always use View.onReceive(_:perform:) to react to external changes and update the view state. Below is the example of how to subscribe to NotificationCenter notifications:

Disabling animation on a View

.animation(:_) modifier was deprecated in iOS 15, so now to disable animations we should use .transaction(_:) modifier that lets us customise the transition between two states. The doc says: "Use this modifier to change or replace the animation used in a view."

forEach vs for

There are some things a for loop can do that forEach can't, and vice versa. for offers a more fine-grained control flow, allowing to exit early with break, as well as to iterate conditionally with for ... where ... . On the other hand,  forEach allows to pass closures to it. In most cases though it simply comes down to personal taste!

jk! reduce is nice sometimes.

On (unnecessary) optimization

The Hidden Costs of Your Dependencies

Ever had to argument why adding a third party dependency to the codebase does not come for free? Here's an amazing concise article summarizing all the different aspects:

The Hidden Costs of Your Dependencies | Jason Zurita

Using a dependency isn’t always bad, but we should be intentional about how and when we use them and what the trade-offs are.

☮️💙💛

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Hope you're safe, wherever you are. I'm excited to share this week's findings with you!

This time I'm doing something new in addition to the usual tips. The pandemic has been hash on the conference scene, and the next conference season is coming up. I figured I'd highlight some conferences that are still looking for speakers.

Enjoy! ☀️

MainActor.run vs @MainActor

You can dispatch a Task to the main actor two ways - by explicitly calling MainActor.run or by annotating the closure with @MainActor. These two ways have different behaviour. If already on the main thread, the former will run immediately but the latter will run on the next runloop cycle. Find detailed explanation in this article by Paul Hudson.

Synchronizing user defaults

Since iOS 12, the synchronize() method on UserDefaults does nothing, and we don't need to call it anymore. It's interesting that the method is not marked as deprecated yet. Here's a quote from the release notes for iOS 12:

Removed synchronization requirements. It’s no longer necessary to use synchronize(), CFPreferencesAppSynchronize(:), or CFPreferencesSynchronize(:::). These methods will be deprecated in a future version of the OS. Now that you don’t need to call these synchronization methods, the performance characteristics of UserDefaultsand Preferences Utilities are slightly different: The time taken for enqueueing write operations is now paid by the writing thread, rather than by the next thread to call synchronize() or do a read operation.

Codable in Firebase

There's now built-in Codable support in Firebase, so there's no need to bring in additional packages such as CodableFirebase. Now you can simply write: ref.getDocument(as: Book.self) {...}. The type just needs to have a property annotated with @DocumentID property wrapper, so the framework knows which property is the identifier. If you want to learn more, Peter also wrote a comprehensive guide.

On refactoring

Wise words here. If one commit contains both refactoring and behaviour change, if things break (or, when) it'll be hard to tell whether they broke due to refactoring or due to a bug in new behaviour. I split these up, always.

Also sometimes people call any change in code structure a refactoring. Here's a quote from Wikipedia: "code refactoring is the process of restructuring existing computer code—changing the factoring—without changing its external behavior."

CloudKit

Did you know that apps using iCloud (CloudKit) cannot be transferred to another account? This means that selling an app with CloudKit can be a tricky endeavour - with the only option being to sell the whole developer account.

iCloud red flag for indie developers

As a consumer, I love iCloud. One central storage for documents, photos and app data. What's not to love? As a developer, I'm much more wary.

Conference time!

This time I want to help the community by highlighting some of the upcoming conferences.

CFP (call for papers) is a format when potential speakers submit their talk ideas. If you've been dreaming about giving a talk - this is your hint to finally go for it 🤘

Looking for speakers

• iOSDevUK, Aberystwyth, UK, 5-8 September 2022. https://www.iosdevuk.com/speakercall-1. They're looking for speakers from underrepresented groups.
• SwiftLeeds, Leeds, UK, 20 October 2022. https://swiftleeds.co.uk/
• 360idev, Denver, US, 28-31 Aug 2022. https://360idev.com/call-for-papers/
• SwiftConf, Cologne, Germany, Aug 17-18, 2022. https://swiftconf.com

New kid on the block

• plSwift - A brand-new Swift/iOS conference in Wrocław, Poland. 25-26 May 2022. plswift.com

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Can't believe this is already the 20th issue  🎉 A milestone for sure. Thank you for your continuous support and feedback - and for spreading the word!

Old new UIKit APIs

When new APIs are introduced at WWDC, we can't use them right away in apps supporting previous iOS versions. And when the time comes, we already forgot about them.

@onmyway133 shares a collection of reminders about cool and useful APIs that were introduced in previous years:

Here's a link to UIViewPropertyAnimator documentation.

Documentation for setCustomSpacing(_:after:) - alas, not very useful.

Here's a link to UITextContentType documentation.

Some useful links: UITabBarItemAppearance documentation, UITabBarAppearance documentation, Using UITabBarAppearance for Tab Bar changes in iOS 13.  Similar API is available for navigation bars: UINavigationBarAppearance documentation, UINavigationBar changes in iOS 13.

Here's a link to KeyboardDismissMode documentation.

Array slice indices

The fact that a slice is just a "view" into the original array can be unexpected and lead to indexing bugs. Convert to the slice to Array(slice) to avoid this, though then new memory will be used.

Int vs UInt

Turns out, the official Swift documentation recommends against using UInt for simply noting values that shouldn't be negative:

A consistent use of Int for integer values aids code interoperability, avoids the need to convert between different number types, and matches integer type inference, as described in Type Safety and Type Inference.

On software design

Have you heard of the broken windows theory? In short, it says that when there's a broken window on a building, more windows will get broken there. One graffiti attracts more graffiti. This is a fairly short article, that nonetheless brings an interesting perspective to the topic of software design and maintenance.

Apply "Broken-Windows" theory to the Software Design

"Broken Windows" is one of the most cited articles in the history of criminology. What can it teach in the world of software development?

The world is still a mess, but I'm really excited to bring you some learnings today. Enjoy! 🙌

The Code Review Pyramid

What to look at in a code review? Check out this infographic shared by @gunnarmorling. Also available on the blog: The Code Review Pyramid

Struct properties - var or let?

Found this conversation thread on pros and cons of making properties in structs  var vs let. I like the take by @myell0w, and you'll find even more opinions in the thread.

Decoding corrupted arrays with Codable

By default, decoding an array of Codable will fail if one of the elements fails to decode. That's not obvious behaviour - and it's not always desirable.

The common way to solve this is to decode as an array of wrapper objects where the model is optional, and compactMap it after. For concrete implementation details, check out the article:

Decode an array with a corrupted element | Sarunw

When working with an unstable, legacy, or third party API, you might get a malformed object in an array. Learn how to decode a JSON array with corrupted data in Codable safely.

Fixing SwiftUI preview pausing

Turns out, structure of the code affects how SwiftUI previews are functioning. For example, changing the default value of a property will pause previews, but if the property is computed - changing the body won't pause previews.

This is because live reloading is implemented using @_dynamicReplacement attribute, which only supports replacing bodies of functions and properties. If you want to learn even more details, check out this article I wrote 2 months ago and forgot to include earlier 😀

Fixing SwiftUI’s Automatic Preview Updating Paused | Marina Gornostaeva

Understand why SwiftUI previews keep getting paused and how to improve the situation

A refactoring story

An entertaining and educational read about refactoring of a complex app. Good with a cup of tea 🍵

Refactoring Uber's Rider app • Space is Disorienting

There was a lot of discussion at the end of 2020 about Uber’s mobile apps. Many wondered aloud why we didn’t just refactor the app instead of rewriting it. I thought I’d add some context into where things were prior to the rewrite.

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

I hope you enjoy today's content. Let's dive in 👇

Documenting app's footprint

Here's an interesting thread where people share how they document where the app saves things and how they like to organise constants. Lots of opinions - some prefer enums, others prefer extensions on UserDefaults. I personally like to use enums as shown in this tweet - making one per-app or per-module depending on the size of the codebase.

Named loops

If you have nested loops, you can label them, and use the label as part of your break or continue statements. This also works for if, switch, do statements. Here's an article with more detailed examples: Swift’s Break and Continue Statements by Andy Bargh

Text or String?

If you also get tired of wrapping strings in Text all the time, here's a tiny extension to make it easier:

Some wise words

I concur:

On passing App Store review

This one is not about improving the code, but improving the release cycle of the app. In this thread @jordibruin shares how he organises his App Store review submissions to minimise chances of getting rejected. Such wonderful advice that I couldn't not share!

He explains what he writes in the messages, attachments he makes, and most interestingly about his FAQ page he shares with the review team.

☮️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

This time I got no cheerful words though. If you're able to enjoy something today - I hope you enjoy these tips.

Uninitialized variables + defer = 👯‍♀️

One of my favourite combinations of Swift's features:

HttpServer or HTTPServer?

Swift API design guidelines have the answer:

Representing measurement units

Measurement is a type that represents a numeric quantity labeled with a unit of measure, with support for unit conversion and unit-aware calculations. MeasurementFormatter has a range of options for presenting measurements in a localised way. Both are available since iOS 10. Starting iOS 15, SwiftUI's Text supports measurement formatting too:

The missing SwiftUI docs

Community-made documentation for SwiftUI types with beautiful examples. For instance, check out TabView documentation to get a taste.

SwiftOnTap

SwiftUI fully documented, with visual examples on every page.

Is there the best architecture?

What works for a tiny startup won't work for a mature product with a large dev team, and vice versa. It's obvious, but still worth remembering when we discuss architectures in abstract.

☮️

Alright, that’s it for today.

Wherever you are, I hope you're safe.

I’d love to hear from you - reply to this email or reach out on Twitter via @ios_code_review 🙌

This time I have exciting news to share - last week we crossed the 1000 subscribers mark 🥳 It's so honouring to be able to share the learnings with such a wide community from all around the world. Thank you for tuning in!

And now, let's dive into the tips 👇

Managing image assets

This is 100% my favourite way to organise assets - images or SF symbols, and even localisation strings.

The best part is that you can easily check in unit tests that none of the assets are missing (or misspelled). Just conform your enum to CaseIterable and test:

Asset.allCases.forEach { XCTAssertNotNil($0.image, "\($0) is missing") }

Use Labels in SwiftUI

Here's a nice short summary of benefits of using Label over just an HStack with Image and Text. I think we should always prefer Label. More details and examples in the documentation.

On counting characters

Few issues ago I wrote about being careful not to mix ranges from String and NSString. And here's a graphic example of how just a simple emoji is counted differently, with explanation why:

On pure functions

This is a great approach to structuring code, and it pairs well with the concept of pure functions:

Visual logging

I started using emojis in logs only recently, and it's life changing on large projects. For log levels, or just easily finding that one print statement you just added.

Memory management with async/await

This article was widely shared so you may have already seen it, but if not - definitely check it out if you're already using concurrency. The biggest takeaway: we have to remember to cancel forever-running observations, such as for await x in in publisher {...}.

Memory management when using async/await in Swift | Swift by Sundell

Managing an app’s memory is something that tends to be especially tricky when it comes to asynchronous code, so let’s take a look at how to do just that when using async/await.

🤘

Alright, that’s it for today.

I have a question for you: I'm sending this newsletter around lunch time in the European timezone. How has your experience been with that? Share your thoughts by replying to this email or by pressing the buttons below.

Hope your Thursday is going the way you want it to go 🌟 Let's dive into this week's highlights!

On mixing Swift and ObjC

Adding a shim layer is a great way to approach moving to Swift in an Objective-C codebase. I can confirm from hands-on experience practicing it successfully on large ObjC projects.

I had this tweet saved in bookmarks for a while, thinking maybe I'll write an article on it some day. But no need anymore - Steve himself just published a great article going deeper on this topic. Huzza! Here's the full article: An Approach for Migrating From Objective-C to Swift

Golden path

Wikipedia describes golden (happy) path as a default scenario featuring no exceptional or error conditions. Swift sure took it to heart by introducing the guard statement. If you are not using it actively yet, maybe this is your sign 😀

@discardableResult

@discardableResult is the proper way to silence the unused variable warning:

Lazy variables are not thread safe

Antoine explains how to avoid data races with lazy variables in this section: How to solve a data race. TL;DR: you can either make all operations with the variable on the same thread, or use actors - the new feature in Swift.

Spell check in comments

Did you know that Xcode has a built-in spellchecker for comments? That's been introduced in Xcode 11. I think it's strange that it's not enabled by default. @felibe444 wrote a quick guide on how to turn it on: Typos in Xcode – Never Again!

HIG for text

Made by @k_katsumi, Apple Localization Terms Glossary is a handy reference point for text in your app. You can easily refer to texts that Apple uses in their UI, as well as see corresponding localisations to other languages.

Another great resource in this area is Apple Style Guide, the official glossary of how to use certain terms. It's like Human Interface Guidelines but for text - definitely worth checking out.

Apple Localization Terms Glossary

An unofficial Apple localization terms glossary that allows you to search for standard localization texts provided by the Apple platform.

‎Apple Style Guide on Apple Books

This book provides editorial guidelines for text in Apple materials. Apple developers and third-party developers should follow this guide for customer-facing text.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Welcome to the first issue of 2022! ☀️

Hope everyone had lovely holidays. I did, and am pumped to jump back into sharing tips regularly. Enjoy!

On counting words

There are multiple problems with splitting words by punctuation and whitespace - even in English "shouldn't" would split into two 'words'. And some languages don't even have spaces. Full article: Three Ways to Enumerate the Words In a String Using Swift by @sorenlind

Working with years in dates

Are you using YYYY or yyyy in your date formats? YYYY represents week year which is the same as calendar year most of the time, but isn't for some dates at the end of December. So there's plenty of time to fix it 😀 Good resources on this:

https://nsdateformatter.com to quickly test different formats. This site also has a nice documentation page where you can get a refresher on which APIs to use when. Or check out the official Unicode documentation if you want to get to the original.

Custom date formats, localized

Setting DateFormatter's dateStyle and timeStyle  result in it producing localised strings. To get a custom set of date components as a localised string, we can use setLocalizedDateFormatFromTemplate(_:):

Learnings from SwiftUI APIs

This is how you set a custom title view in the navigation bar in SwiftUI. How would one ever guess that this is how it should be done? ToolbarItemPlacement.principal  has a small paragraph about its effect. In my opinion, this API is not discoverable at all. (thanks @sarunw for sharing this!)

Two learnings here: 1) SwiftUI is still cool and powerful, you can do so much with so little code 2) With great flexibility of API, the understandability can take a hit. Because it will behave differently in different contexts and different platforms, SwiftUI has to use overly generic terms such as 'toolbar' or 'principal placement'. So users have to resort to documentation for understanding what it even means. This is a big tradeoff and something to keep in mind when designing our own API.

StoreKit resources

Stumbled onto two repos with comprehensive information on working with StoreKit APIs. There is a repo for StoreKit 2 (new in iOS 15) and a repo for the good old StoreKit. If you're looking to implement in-app purchases from scratch, these are great as reference after checking the official Apple documentation.

Both repos have a mile-long readme with every little detail covered, as well as working code that covers every edge case - unlike the official samples provided by Apple. Made by @archer_russel

GitHub - russell-archer/StoreHelper

Implementing and testing In-App Purchases with StoreKit2 in Xcode 13, Swift 5.5 and iOS 15.

GitHub - russell-archer/IAPDemo

Implementing and testing In-App Purchases in Xcode 12 and iOS 14, including local receipt validation.

Review PRs in IDE form

Did you know that you can review PRs in Github in a full-blown IDE right in the browser? I find it more convenient, being able to navigate between files and having extra code highlighting. You can even make edits. Inline PR discussions are included. Press `.` (dot) while on the PR page, or change the url from GitHub.com to GitHub.dev.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Simply reply to this email, or reach out on Twitter via @ios_code_review 🙌

Welcome to the 13th issue, the last one for 2021. As a treat, there are a few more tips than usual. Enjoy!

Happy holidays and see you on January 13th! ❄️

Changes to app launch sequence

On iOS 15, iOS might pre-warm your app by initialising the app delegate & co few minutes before the user launches the app. application(:didFinishLaunching:...) will be called when the app is finally launched, but other resources are loaded earlier.

The culprit is that some resources such as keychain might not be available, as the device might be still locked. So we shouldn't be initiating any work or for example checking of the API token presence earlier than application(:didFinishLaunching:...). Check official documentation on this behaviour here: About the App Launch Sequence.

Solving Mysterious Logout Issues on iOS 15 | Source Diving

At Cookpad, after the public launch of iOS 15 we started to receive reports from users telling us that they were being repeatedly logged out when opening our app. This came as quite a surprise since…

Learning from CLLocation APIs

Two learnings here: 1) desired location accuracy in CoreLocation can be set to a custom value in meters 2) how not to design an API 🤡 Here it's understandable though - this API comes from pre-Swift times and needs to be compatible with Objective-C, so it couldn't be modelled with enums with associated values. Thanks @Kilo_Loco for the find!

Printing HTTP status codes

Turns out Foundation has a method for producing human-readable strings from HTTP status codes: HTTPURLResponse.localizedString(forStatusCode:)

Easy boxes in SwitUI

GroupBox is a SwiftUI component that replaces the setup with VStack + padding + mask. GroupBox can be customised with different styles, though there's only one provided out of the box. We can build our own styles,  here's a great article on that: Mastering GroupBox in SwiftUI on Swift with Majid.

Common compositional layouts for UICollectionView

Filip has shared an awesome collection of various compositional layouts in his Github repo. If you are looking to start mastering UICollectionViewCompositionalLayout or NSDiffableDataSource*, I recommend checking it out.

Working with arrays in real apps

If you need to take an item from an array, perform an asynchronous operation with it, and update it in the array, how do you do that safely without messing with indexes, which can change in the meantime? That requires some careful code that would need to be unit-tested.

This is a library for working with identifiable objects in collections, making it easy to access elements by identifiers instead of indexes. The readme goes more into the use-cases and problems with access by index.

GitHub - pointfreeco/swift-identified-collections

A library of data structures for working with collections of identifiable elements in an ergonomic, performant way.

Some philosophy

Some of you are working in small companies, and some in bigger cos. This tweet isn't really code related, but I feel that it applies to anything. I've never thought of it this way before, but the distinction applies so clearly to all the teams I worked at. Which culture do you want to foster?

☃️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

How is your week going?

I hope you enjoy today's tips. Let me know what you found most interesting by replying to this email 🙌

Tired of translatesAutoresizingMasksIntoConstraints?

Two neat ways to deal with the good old (and annoying)  translatesAutoresizingMasksIntoConstraints 👍

Or like that:

let label = UILabel().forAutoLayout()

Type-safe identifiers

When we use string or int for identifiers, it can be easy to accidentally pass the wrong value to the function that takes a said identifier. @mecid wrote an article on using phantom types to make API that works with identifiers type-safe, so the compiler does the checking for us.

Understanding SwiftUI navigation

A nice short write-up on the current state of navigation in SwiftUI.

While the repo itself contains tools that you can use in your code, the readme goes over the issues that out-of-the-box navigation API has and potential directions for solving them.

It's a valuable resource for understanding how to deal with navigation better, even if you don't wish to use third-party code.

GitHub - pointfreeco/swiftui-navigation: Tools for making SwiftUI navigation simpler, more ergonomic and more precise.

Tools for making SwiftUI navigation simpler, more ergonomic and more precise. - GitHub

Improving old code

This is a great approach to working on old code. Old code can be improved significantly even by small refactoring - it's not always necessary to make big changes to make impact on code quality.

On non-fatal errors

We often write checks like this one:

guard let requiredValue = value else { return }

In reality, when this case happens, the user will just see that nothing happens in response to their actions, and the developer will never know about such cases. Force unwrapping and crashing the app is not the answer either.

Antoine discusses ways to approach this problem in his recent article.

✌️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

I hope you enjoy this week’s findings ☀️🙌

On text truncation in SwiftUI

Once I spent a whole day debugging a text truncation issue in SwiftUI. I had a list of views with multiline text in each. All was good, but on rare occasions one of the views would have truncated text. It would be seemingly random - the same item would be truncated or not depending on which position in the list it was in.

Eventually it turned out that I "just" needed to add fixedSize(...) modifier to the Texts. It tells the text to take its ideal size (it's called intrinsic size in UIKit).

It bugs me that multiline text mostly works without it, so you think all is fine until you catch the truncation on some specific input. Do we have to use it on all multiline texts to avoid these issues? Apparently.

Compiler + enums = 🧡

This tip might be obvious to most devs, but this feature of enums is so useful to me, that it's worth sharing still. The idea is to always spell out all enum cases in switch statements, so the compiler helps out when a new case is added.

If you use default mainly because there are many cases that don't need handling, you can list cases with a comma: case .a, .b, .c, .d, .e: break

More on logging

Last issue included a tip on print() vs os_log(), and today I have a tip for you if you're still using NSLog(). The first parameter is a format string, containing 0 or more format specifiers starting with % (fx %@ or %f). We shouldn't include interpolation in format strings - it's a matter of time until a printed url or error contains these symbols by accident - causing a crash.

Michael Tsai - Blog - Dangerous NSLog() Calls in Swift

In the scenario of my crash, the interpolation of “url” and “error” results in surprise template placeholders, because of the presence of spaces in the path that the URL represents. In my tests, a file called “Open Program Ideas File” exists and is used to test some file manipulations. When the path to this file is encoded as a URL, the name of the file becomes “Open%20Program%20Ideas%20File”.  Each instance of “%20” followed by a letter is liable to be interpreted by NSLog as a printf-style format specifier. So as far as our filename’s string is concerned, we have “%20P”, “%20I”, and “%20F” threatening to cause trouble.

Passing around object ids

Quick tip from this morning on improving readability of your code that works with Identifiable models. This protocol is part of Swift Standard Library, so it's relevant even if these models are not used in SwiftUI.

Bugs: not an if, but when

A bit of philosophical content here. It resonated with me a lot - I've been training table tennis most of my life, and I can relate to the analogy in this article. Unless you're significantly better than the opponent, you're actually just trying to minimize mistakes and keep the ball in play as long as possible.

When we develop long-living software, we're just trying not to lose - to bugs, technical debt, scaling issues. I love this way of looking at why we do unit tests, code reviews and regular maintenance.

ifwhen

Software development is a loser’s game | by Ben "The Hosk" Hosking | Medium

I’m not saying developers are losers but most software developers are not beating software development, software development is beating them.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below.

Thanks for your ongoing feedback! Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Hope your Thursday is going the way you want it to go 🍁 Let's dive in 👇

async/await is really here

While it's undoubtedly a superior way to write asynchronous code, I generally stayed away from async/await-related tips, because no one could really use them yet. I wrote about the issues few weeks ago. But not for much longer!

Xcode 13.2 beta was released yesterday with support for backward deployment of async/await all the way back to iOS 13. This is achieved by embedding the Swift runtime with the app, like it was done before Swift gained ABI stability.

If you're open to trying it out for real in your projects, the Swift team is actively seeking feedback and issue reports during this beta period to help make the backport more stable. Just download Xcode 13.2 beta and try async/await features on your iOS 13 or iOS 14 device.

print() vs os_log()

A reminder about print() being slow. If you print something frequently, the lag can be really noticeable.

There's a way out - you can use os_log API instead. It doesn't slow the app down, and as an added benefit logs can be seen both in the debugger console and in Console.app, even on release builds from App Store. An even cooler thing is that interpolated values are redacted in release builds, unless included with %{public}@ instead of %@.

To learn more about os_log, check out the best article ever about os_log from @twannl. To learn about shortcomings of os_log, check out Problems with os_log by @mjtsai.

Managing fallbacks

There are a lot of new views and modifiers in SwiftUI that can only be used from iOS 15 and up. If you support iOS 14 too, then you might use fallbacks there.

@davedelong came up with a nice approach - housing custom fallback code under .backport, so it's easy to find usages in the project and remove fallbacks later when you drop support for iOS 14.

If it looks confusing, this short article by @ralfebert goes step-by-step into arriving at this approach: Using iOS-15-only View modifiers in older iOS versions

A good custom operator

Custom operators are usually confusing to readers of the code, and many developers don't like them for this reason. But I found a really nice use-case shared by @twannl. The meaning is clear enough at call site (in my opinion), and it actually would save lots of typing in a project where colors are used extensively in the code:

--

and just to end on a reassuring note - I think a lot of us feel this way right now. It's totally normal 🥲

✌️

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter further.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

It's that Thursday again 🥳 I found so many gems in the last few weeks, that today's issue contains more tips than usual. I also re-tweet additional tips throughout the week that didn't make it into the newsletter, so make sure to follow @ios_code_review for even more tips.

❤️ SwiftUI previews

SwiftUI previews can be very handy for other use-cases besides previewing SwiftUI views.

You can use previews to preview UIKit views, which can save you dozens of hours in rebuilding to see your changes:

GitHub - theoriginalbit/PreviewView: Make use of SwiftUI Previews for UIKit!

Make use of SwiftUI Previews for UIKit! Contribute to theoriginalbit/PreviewView development by creating an account on GitHub.

SwiftUI previews can also be used to preview app themes and other code-only visuals such as generated images:

On manipulating strings

Swift's strings are unicode-compatible in the best way, counting the real displayed graphemes as the user would see them.

We need to be careful though when working with NSString APIs, because they deal with unicode differently. In the example below, print((word as NSString).length) would print 5 , not 4. So be careful not to apply ranges returned from NSString-based APIs to  String instances.

❤️ SF Symbols

SFSymbols are really powerful these days. They support thickness, styling and even multiple colors. What you see here on the screenshot is achievable with just native APIs on iOS 15. For an overview on how to use SFSymbols in SwiftUI and UIKit, check out The Complete Guide to SF Symbols by Paul Hudson. There's also an official Mac app for browsing and previewing all available symbols.

Unit testing retain cycles

Sometimes it's useful to test not only what a type does functionally, but also that there are no retain cycles and an instance deallocates as expected. This can be useful for view controllers and other complex classes dealing with closures and dependencies, where retain cycles are common.

Here's a short snippet by @ZiadeMarcus for verifying that an instance has deallocated after a test. It uses addTeardownBlock which is pretty neat on its own and can be used for other purposes too.

Assert failure messages

We write unit tests with the intention that they pass, but they really help us when they fail and catch errors in our code. So we should strive to have useful failure messages that hint at what's wrong. Not all assert failures provide insight out of the box - @basthomas gives an overview of commonly used XCTAssert* functions and how their failure messages are reported:

(Improving Your) XCTAssert* Failure Messages | Bas’ Blog

A couple of debugging tricks

In iOS 15 you can do po [tableView _rowData] in the debugger to print the internal geometry (e.g. heights, y-offsets for each row, etc) of the table view. This can be useful to track down why things look the way they do. For Swift, it would be po tableView.value(forKey: "_rowData”)!. This tip was shared by @smileyborg.

Another trick is to print app's view controller hierarchy with po [UIViewController _printHierarchy]:

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

It's Thursday again ✨ Got a few really interesting things to share. Let's dive straight in 👇

Status of async/await

Considering to start using async/await for real? Here are some things worth knowing before you do. Backporting to older iOS versions is proving challenging and might not happen; and a few serious issues and crashes have been found on the current version shipped with Xcode 13 / iOS 15.0.

I was excited to start using this for real, but will be holding off until there's a more stable version out there.

Swift 5.5 has serious stack corruption bugs! - Compiler - Swift Forums

hi all, I’ve discovered several stack corruption bugs related to async/await which can be reproduced in simple test programs compiled with recent nightly toolchains. i have confirmed that two three four of these bugs are…

Catching errors

There are so many ways to write catch statements in Swift. It's as flexible as switch statements, and same as switch statements also verifies that all possible errors are handled, producing a compiler error otherwise.

Check out Sarun's article for detailed examples of each case. Here's the official language reference on patterns in Swift.

Modern dependency injection

Dependency injection as a design pattern can manifest in different ways - from passing dependencies at initialisation to service locators and 3rd party libraries. (here's a nice overview of the good old ways from 2019 by @kofse)

Inspired by SwiftUI's @Enviroment, nowadays dependency injection can be made simpler and easier to use, thanks to Swift's latest features such as static subscripts, extensions, and property wrappers:

Dependency Injection in Swift using latest Swift features - SwiftLee

Dependency Injection using latest Swift features allows you to mock data, and write tests easily without 3rd party dependencies.

Margins on UIStackView

Did you know that UIStackView supports layout margins out of the box? With one small boolean property isLayoutMarginsRelativeArrangement we can ask the stack view to lay the content within its layoutMargins instead of its edges. And it respects safe area out of the box, thanks to UIView's insetsLayoutMarginsFromSafeArea which is true by default.

If you want to learn more about the layout margin system in UIKit, I gave a whole talk about it at NSSpain in 2019 :)

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Happy Xcode RC week! The release notes are extensive, but nonetheless are worth checking at some point, because there are many small improvements that are not mentioned anywhere else. I'll be going through the changelog myself, and will post anything that can improve our code 🙌

Let's dive in 👇

Crash in Combine

It's almost a tradition now to start the newsletter with a tip about an obscure Combine issue... This time, it turned out that breakpointOnError() crashes apps. To solve this, you can make an extension that conditionally uses this only if debugger is attached. But I just comment it out completely when not debugging 😅

SwiftUI + Combine = 🧡

SwiftUI's onReceive opens some really interesting possibilities. Here's @danielsaidi with an example showcasing the power of SwiftUI when you sprinkle extra Combine on top. This code subscribes to a data binding of a UI element (a form in this case) and pipes changes into a save function. Makes the UI code really concise and pretty hard to break.

Swift API design guidelines

Saw a tweet the other day, a person saying that they wish Swift had an official API guideline. So a refresher just in case - it does! Makes you a pro at writing function signatures that feel right at home in Swift.

Swift.org - API Design Guidelines

Swift is a general-purpose programming language built using a modern approach to safety, performance, and software design patterns.

Lazy local variables

Starting with Swift 5.5 (shipped with Xcode 13), we can use the lazy keyword on local variables. Code that had to use closures to achieve this lazy behaviour can now be simplified 🎉

Time-based git diffs

Git supports a bunch of ways to reference commits (revisions): by commit hash (full or short), branch name, HEAD~n to jump back n commits, etc. Apparently you can not only reference commits, but also reference a specific moment in time. Thanks to @trevorbrindlejs for sharing this.

If you want to learn about all the ways to reference revisions, check the documentation.

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

How is your Thursday going?

iOS 15 GM is right around the corner, people are buzzing about last moment API changes and additions. And I'm here with some good old code improvement tips 😀👇

Waiting on multiple async calls

Have you seen code that's running multiple async calls in a loop, calling completion on the last item in the loop? Or counting the number of callbacks called? I've seen it a lot, and the last time has prompted me to share this tip 🙂

DispatchGroup allows you to wait on multiple async operations, as complex as they may be. The concept is simple: the dispatch group keeps track of how many tasks are outstanding (unfinished). enter() and leave() calls increment and decrement the internal counter. Once the counter reaches zero, your custom closure is called. Here's a small example by @joemasilotti:

Conditional modifiers are bad? 😬

Are you using conditional modifiers in SwiftUI? I am 🙈 Folks at @objcio came out with a detailed explanations on why it's not such a good idea. SwiftUI uses the type system for diffing of state, and conditional modifiers such as applyIf(...) break that.

The article also dives into why SwiftUI works the way it does, so check it out if you want to learn more: Why Conditional View Modifiers are a Bad Idea

Timers, scrolling, run loops

When you use Timer.sheduledTimerscheduledTimer(withTimeInterval:...), it will not trigger while the user is interacting with a scroll view, or is performing any other touch-tracking interaction. The timer will continue after the interaction has ended. That's because this convenience method auto-schedules the timer in the .default runloop mode, and the default mode doesn't check the timer during touch interactions.

If you want the timer to continue as normal during touch events, you'd have to init and schedule the timer with .common mode manually: RunLoop.current.add(timer, forMode: .common)

@qdoug shared a handy cheat-sheet for remembering which mode to use, as their names are super confusing:

Review the resources too

A fascinating anecdote shared by @krzyzanowskim. 98% of an app's size is icons, 11 MB each. That's nearly 1600x1600px. Why a png icon need to be this big? I bet this is not intentional, and these folks can reduce their app size at least 5x by including appropriately-sized images.

AKA this is a reminder to review the assets that are being introduced to the app, and not only code 🙃

Quick 2-in-1 tip

1) NSCache exists and is a good alternative to a plain dictionary when you want to cache non-trivially sized items

2) How feedback is delivered is extremely important. Simply being friendly goes a long way ✨

🤘

Alright, that’s it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I’d love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

Hope your Thursday is going the way you want it to go 🌟

Let's dive in right away!

Check your back buttons

Do you remember about this obscure feature added in iOS 14? Holding the back button shows the navigation stack history and lets you navigate to any item. Cool feature, right? Not so fast...

The titles are taken from the back button. If you're still hiding the back button titles by setting navigationItem.backButtonTitle = "" , you will have this bug, where rows are just empty. I checked some popular apps and many of them have this issue 😵

Since iOS 14, there's a proper way to hide the back button title by using backButtonDisplayMode. @sarunw wrote a detailed guide on it, make sure to check it out!

PS. if you're on SwiftUI, remember to add the .navigationTitle(_:) modifier even when you hide the navigation bar on that view.

A new way to manage the back button title in iOS 14 with backButtonDisplayMode | Sarunw

Apple adds a new way to control where the back button will pick up its title. Let's see how this make thing a lot easier going forward.

On force unwrapping

Yet another debate on force unwrapping happened last week. With usually no end in sight for this polarising topic, we might have found the answer.

I loved this perspective from @johnhaney: both sides of the debate have the same goal - to account for the nil cases. The only difference is that for some, it's to think of it right away, and for others, only to do that if&when the crashes happen in production and become a problem.

Check the whole thread if you want to read other interesting opinions.

Testing throwing code

Test code is also code. @nicklockwood shares three tips for modernizing the implementation of your unit tests with XCTUnwrap and marking test functions as throwing:

Pro rebase tip

If you're using rebase and are switching branches in the process, this tip will save you a bunch of friction. This is an older tweet, but I regularly meet people who are unaware of this trick, so here it is :)

If you're unsure why one would want to use rebase, I recommend reading the Demystifying Git Rebase article series.

🤘

Alright, that's it for today.

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? Want to see more, or less of certain kinds of tips? I'd love to hear from you. Reply to this email or reach out on Twitter via @ios_code_review 🙌

In today's issue, among other things, @v_pradeilles shares two video tips, memory leaks in Combine make a come-back, and we fix Copilot's code. Let's dive in 👇

When not to use [weak self]

@swiftandtips found a well-structured writeup on when to use and not to use [weak self] in closures. Here's a concise chart to help you decide.

If you also want to learn the why's, read the full article: You don’t (always) need [weak self] by @BesherMaleh

Lazy collections for speed

Love the new tip series by @v_pradeilles. In this short video he demonstrates speeding up his code 400.000 times just by adding .lazy. Yes, only five characters 🔥 Watch full video on Youtube (6 min)

There's no secrets in UserDefaults

And another tip from @v_pradeilles. You've likely heard that saving sensitive data to UserDefaults is a bad idea, but perhaps weren't sure why?

Vincent recorded a short tutorial demonstrating how the data saved in UserDefaults can be easily accessed. Watch on Youtube (4 min)

Memory leaks in Combine

We've touched on this topic in the Issue #3. Well, there are always more places to find retain cycles in.

If you're binding a publisher's values to a property of a class, watch out for which operator you use. Using .assign(to: \.property, on: self) will retain self and may cause a retain cycle. On the other hand using .assign(to: $property) retains the property's publisher, not self.

This old forums thread has an example of leaking code. Know your enemy!

Does 'assign(to:)' produce memory leaks? - Using Swift - Swift Forums

Hello there! I'm playing around with Combine and I've found a possible memory leak when using 'assign(to:)' to store stream result in current object. Let me show a couple of examples using 'assign(to:)' and 'sink' to co…

Remember Copilot?

In Issue #2 I asked for your suggestions on what can be improved in Copilot's code, and you sent some great suggestions! There are many things that could be improved there. Did you notice that it doesn't even compile?

I made a playground with four improvement iterations. Check it out to see if you've spotted everything, or if there's anything we missed 👀

✌️

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? I’d love to hear your thoughts! Reply to this email or reach out on Twitter via @ios_code_review 🙌

I hope your Thursday is going well ☀️ Today's issue covers topics such as architecture, Combine, Swift, SwiftUI, UIKit, and development process. Let's dive in!

Architectures are for humans

Last week a particular topic resonated through the community: the mental toll the different architectures bring on developers. The issue is especially prominent for complex architectures such as VIPER, which is known for having many similarly-named small files per each screen.

@collinodonnel shared his experience, which triggered many others to come forward. Dozens of developers shared similar experiences last week.

Any task required routing through six classes, and I found myself physically exhausted when I had to interact with it.

I have struggled with VIPER myself in exactly the same way.

Let this serve as a reminder to all of us. Not that VIPER is a bad architecture pattern, but that architectures are not only about clean code or testability. They're also about people. It's us humans who have to be able to understand the codebase, reason about it, and work on it - productively.

Retain cycles with Combine

Combine's map operator retains the transform closure during the publisher's lifetime. When we pass a function declared on self, self is retained as well. If the subscription is kept alive by the same object, then we have an unbreakable retain cycle that prevents self from ever deallocating.

Marking self as unowned would leave the possibility of the app crashing. @eneko shares a safe way to resolve the retain cycle:

Configuring SwiftUI views with Environment

Majid shares a real-life example of how to leverage custom environment variables to configure custom SwiftUI views. Check out his article if you want to understand SwiftUI's Environment better.  The way we do things in SwiftUI is definitely different from how we used to do them in UIKit 🙈

Reverse arrays for free

An interesting fact shared by @swiftandtips: reversing an array with reversed() doesn't use any new memory, and has constant time complexity (read: is very, very fast).  Read documentation with examples here.

Detecting orientation changes in UIKit

Why do we want to know about changes in device orientation? Most often it is to know about screen size changes. In today's variety of devices, device orientation is not the only possible cause for the app's window to change size - think moving the app to split screen on iPad. Individual view controllers can also change size - f.ex. when changing width of columns in UISplitViewController.

Because of all this, it's much safer to rely on viewWillTransitionToSize for concrete size changes in view controllers, and on traitCollectionDidChange for general changes in environment, such as size class, dark mode, preferred text size and so on. Thanks @mluisbrown for bringing this up!

Getting unstuck in the morning

This tip is not about tweaking the code, but about tweaking your own development process. Are you sometimes feeling stuck when picking up a new task in the morning? There are some smart ideas in @nicklockwood's thread.

My favourite trick is to create the pull request in the morning, even if I finished the implementation and pushed the commits the day before. Besides the productivity boost, it gives a chance to look at the solution with fresh eyes and think of missed edge cases.

✌️

Did you enjoy this issue? Let me know by pressing the buttons below, so I can improve the newsletter.

Got feedback? I’d love to hear your thoughts! Reply to this email or reach out on Twitter via @ios_code_review 🙌

Even though it's summer and many are on vacation, there is no shortage of things that we can learn from our awesome Apple developer community.

I hope you enjoy this week's findings ☀️🙌

Function annotations for structs

If you write Swift, most likely you use structs a lot. John Sundell goes in depth on how marking functions in structs mutating can help you make code more structured and concise.

Mutating and non-mutating Swift contexts | Swift by Sundell

What sort of capabilities that a mutating Swift context has, and what the mutating and nonmutating keywords do.

Handling actions in UIButton

Did you know about UIControl.Event.primaryActionTriggered? It's been around since iOS 9.0, and it makes touchUpInside obsolete for button action handling. It also makes accidentally picking touchUpOutside and wondering why the button won't work for an hour less likely. touch* events are still useful for handling touch movements in custom controls, but we can simply use primaryAcitionTriggered in day-to-day. via @_mochs

On testing and refactoring

Stumbled onto this quote from 2017, and I just had to share it. In my view, this is the best way for us developers to view ourselves as professionals in our field.

"I don't ask permission to write a test or refactor, any more than I ask for permission to write an if statement or a for loop" - @RonJeffries

Working on multiple branches in git

@rockbruno_ uncovered an awesome git feature: git worktree allows us to check out multiple branches at once in the same repo. git worktree has benefits over cloning multiple copies: you save on disk space (in case your repo has long history) and all worktrees share the same local branches and stashes.

You can use worktrees to have parallel branches checked out long term, f.ex. an older version of the app for comparing functionality, or just to quickly check out coworker's branch during code review.

Let's review Copilot's code!

A lot has been said already about Github's Copilot tool, good and bad. I don't have access yet, and I'm sure not many of you do. While we wait, let's review Copilot-suggested code!

How many bugs and improvement opportunities can you find in this piece shared by @krzyzanowskim?

Let me know by filling a one-question form, all anonymous of course. If I get enough replies, I will share most popular ones on our Twitter next week.

✌️

What did you think about these tips? I’d love to hear your thoughts on Twitter via @ios_code_review or over email at ioscodereview@hybridcattt.com 🙌

This issue was actually never sent to anyone. I've just created the newsletter, and this is a sample of how the future issues might look. I will share the valuable code improvement tips I stumble upon while browsing Twitter, spiced by occasional comments from my side. I cover Swift, Objective-C, UIKit, SwiftUI and much more. The plan is to send the newsletter every two weeks or once a month.

This issue contains my most favourite tips from 2020. Code improvement tips rarely age, so I hope you find these useful 🙌

Change suggestions in PR comments

While multiline change suggestions were introduced on Github all the way back in February 2020, it's such a time saver during code reviews, that it is worth reminding about.

When a you use change suggestions in PR comments, the changes can be incorporated automatically with a click of a button in the web UI, without having to first apply requested changes locally and then pushing to remote.

Tired of translatesAutoresizingMasksIntoConstraints?

This is the nicest way I’ve ever seen to deal with translatesAutoresizingMasksIntoConstraints.

let label = UILabel().forAutoLayout() // just like that 🤯 by @ZiadeMarcus

Access control for performance

It's not obvious that choices such as marking types and members private or final, or choosing between using struct or class are not only code style preferences, but also affect performance. Read the article by Avi Tsadok:

9 Ways to Boost Your Swift Code Performance | by Avi Tsadok | Better Programming

Swift is a fast language and it gets faster in every release. iOS devices are also fast, so the chances are these tips won’t be needed at all. Even in those cases where we do bump into performance…

Any documentation > no documentation

A reminder that even smallest bits of documentation can be helpful. via @SergDort

Minimalistic functions

I love this idea of functions only taking the most specific parameters they need, courtesy of @Jonathanff. This approach doesn't only improve reusability, but also reduces unwanted side effects (possibility of changing something you didn't mean to change) and makes code easier to review. It's not a silver bullet though, so use with care.

Tech debt as a tool

Adding tech debt is acceptable in some cases, and is often necessary. @danielsaidi shares a solid approach to accepting technical debt:

To end on a fun note...

Nothing and no one is perfect, let's just remember that we're all human 😇

✌️

What did you think about these tips? I'd love to hear your thoughts on Twitter via @ios_code_review or  over email at ioscodereview@hybridcattt.com 🙌