Until recently, I was still skeptical about using AI for coding!

I think part of that skepticism came from not fully trusting the quality of the output. Another part came from not wanting to become dependent on suggestions I did not fully understand. And, if I am being honest, I also felt these tools often looked much better in demos than they did in real project work.

That started to change this past week.

For a full week, I used GitHub Copilot much more intentionally in my day-to-day work. Not just for quick autocomplete suggestions, but as part of the actual development flow: asking it to help me reason about changes, break down tasks and move faster through implementation.

By the end of the week, my perspective was different.

This edition is a reflection on that experience: what worked, what did not, and what helped me move from resistance to a more practical mindset. I increasingly feel that this is something we should learn to work with instead of spending too much energy fighting against it.

These thoughts come from my experience using the GitHub Copilot Business plan. Do not take them as granted, they are just honest notes from my own daily workflow.

My setup during this week

At first, I wanted to use Copilot straight from Xcode through CopilotForXcode.

I gave it a fair try, but it still does not feel reliable enough for my day-to-day work. What ended up working better for me was this:

• Xcode for my regular development work
• Visual Studio Code when I want to use the agent in a more intentional way

It is not the ideal setup, but it has been much more dependable.

What helped the most

The one thing that improved the experience the most was this: start a new conversation for each new feature.

I noticed that when a conversation became too long, the agent gradually lost focus. In some cases, that also led to hallucinations.

Keeping each conversation tied to a specific goal gave me much better and more predictable results.

Where I went wrong more than once

A mistake I made several times was trying to get too much done in a single prompt.

When I asked for a large change all at once, the agent often struggled to stay focused. I would see it:

• touch files I did not mean to change
• make edits unrelated to the original task
• move away from the outcome I actually wanted

Now, whenever I notice that happening, I pause and break the task into smaller parts.

What works better for me is:

• start by asking for a plan
• move through the work step by step
• review each step before going further

This made the workflow much safer and a lot less noisy.

MCP support ended up being really helpful

One other thing I explored this week was MCP support.

I set up the Atlassian MCP Server, and it worked surprisingly well for giving the agent richer context about my tasks.

Having Jira details available in the conversation made it easier for the agent to stay aligned with what I was actually trying to do. That mattered more than I expected, especially when the work involved product requirements, task history, or details that were not obvious from the code alone.

In practice, this was one of the improvements I found most valuable!

The biggest takeaway for me

If there is one thing this week made clear to me, it is this:

Make sure you understand the fix before accepting it.

If I cannot explain why a solution works, then I am not in a good position to validate it. And if I cannot validate it, I should not be relying on it.

Copilot can speed up the process, but it does not remove our responsibility to make sure the code is correct.

Final thoughts

After spending a week with GitHub Copilot in my iOS workflow, my impression is positive, though definitely more realistic now.

It can be a very useful tool when the problem is clearly defined and the context is solid. But once the scope gets too wide and validation becomes weaker, things can go off track quite quickly.

The biggest change for me is not that I now trust the tool blindly. It is that I now understand better where it fits in my workflow, and where I need to slow down and think for myself.

I plan to keep using it, just much more intentionally than I did on day one.

Have a great week ahead 🤎

Can you believe it's already March? February seemed to fly by.

This week our app design team gathered at our Aveiro office for three days focused on refining the UI-tweaking details, polishing pixels, sharing meals and enjoying some great moments together.

Even though I strongly support remote work, I truly value these in-person work meetups. They help strengthen team connections and give us the chance to know the real people behind the avatars and Microsoft Teams windows.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

Modularizing Swift Apps with SPM

If you've ever worked on an app that grew beyond a small set of files, you probably know the pain: slower builds and small changes triggering recompilation across the entire target.

Kyle explains how to organize a Swift app using local Swift packages with well-defined layer boundaries. By separating features, services, and shared components, large projects become easier to maintain and test. This article is part of a series, and it's definitely worth reading the rest of the posts.

NSCache in Swift: A Practical Guide

In Artem's latest article, he explores how NSCache actually works and where it fits within a real production iOS architecture.

When dealing with heavy feeds, rich text rendering pipelines or complex view hierarchies, this caching layer can help eliminate unnecessary recomputation while keeping data correctness intact.

Essential Swift Package Manager Commands

Swift Package Manager includes many helpful commands beyond simply building packages, though many developers only use a small portion of them (myself included).

Mehmet shares a practical list of commands that can simplify everyday workflows, covering everything from building and running packages to testing and preparing release builds.

Agentic Coding

In this article, Rui writes about his experience using AI for coding along, sharing how adopting agent-driven workflows allowed AI to plan tasks, write code, run tests, and iterate with minimal manual input.

It's been a busy week at work, but I still wanted to pass along a few articles and updates that stood out to me recently.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

🪦 CocoaPods Trunk Read-only Plan

After 15 years of dedicated service, CocoaPods is coming to an end! Starting December 2, 2026, the CocoaPods trunk will switch to permanent read-only mode. No new libraries will be added, and no existing ones will receive updates.

If you're an iOS developer still relying on CocoaPods, it's time to begin gradually moving over to Swift Package Manager.

📸 Automated App Store Screenshots with Fastlane: A Practical Guide

I'm pretty sure most of us rely on Fastlane in our projects for some level of automation. But are we really making the most of what it offers? I know I'm not! 😅

In his guide, Kamil explains how to set up automated screenshots and highlights why building solid test infrastructure is a worthwhile investment for every release cycle.

💵 Tracking token usage in Foundation Models

With iOS 26.4, Apple introduced token usage tracking in the Foundation Models framework, enabling developers to monitor computational costs and context limits for on-device AI models.

Artem published a great piece this week diving into the topic, exploring APIs that let you measure token usage at different levels, from single instructions all the way to complete conversation transcripts.

⏰ How to measure execution speed in Swift

There are many scenarios where it's useful to measure how quickly your code runs, whether you're verifying the performance of network requests or developing an analytics provider.

Although Artem's article on this subject is nearly two years old, the techniques he describes are still relevant and can help determine when performance optimization is important.

Last week, we carried on with our "Start building with Rive for iOS" series and wrapped up part 3.

If you haven't had a chance to read it yet, I recommend checking it out first to get the most value from the series.

Now, we're moving on to part 4 and last edition of the series, where we'll explore topics like creating advanced workflows with Rive Scripting and improving the animation logic using the AI coding agent.

The Plan

In this edition, we'll put together a particle system using the new Scripting feature and produce a fully dynamic falling-particle effect. To wrap things up, we'll export the Rive animation and run it with the Rive runtime on iOS.

If you haven't worked with Scripting before, I recommend checking out Rive's official Scripting videos before continuing.

Creating Artboards

To start, we'll create an artboard for a single particle in the Rive editor. I'll set its dimensions to 200×200 pixels and name it Particle. Then, I'll upload an image of my newsletter sticker and place it onto the artboard. After that, I'll align it to the center, scale it so it fills the artboard, and turn the artboard into a component so it can be reused later.

At this point, we have a reusable particle component. Here's what it looks like:

<StaticHalfWidthRemoteImage src="/issues/issue68/particle-artboard.webp" alt="Turning the Particle artboard into a component." link="/issues/issue68/particle-artboard.webp" caption="Turning the Particle artboard into a component." />

Next, we'll add the main artboard, which will be used to build the actual particle effect.

Let's create a new artboard sized at 850×1650 pixels and name it CoffeeParticles. We'll also turn this artboard into a component. Here's the result:

<StaticHalfWidthRemoteImage src="/issues/issue68/coffee-particles-artboard.webp" alt="Turning the CoffeeParticles artboard into a component." link="/issues/issue68/coffee-particles-artboard.webp" caption="Turning the CoffeeParticles artboard into a component." />

Finally, we'll create a script capable of generating these particles dynamically.

Creating Scripts

To add a script, open the toolbox and select a type of script. I'll choose a Node Script for this setup. Node scripts allow you to draw shapes, images, text, artboards, and more. Rive automatically provides some starter code, which we'll modify and reuse to build our particle system.

-- Define the script's data and inputs.
type MyNode = {}

-- Called once when the script initializes.
function init(self: MyNode): boolean
  return true
end

-- Called every frame to advance the simulation.
-- 'seconds' is the elapsed time since the previous frame.
function advance(self: MyNode, seconds: number): boolean
  return false
end

-- Called when any input value changes.
function update(self: MyNode) end

-- Called every frame (after advance) to render the content.
function draw(self: MyNode, renderer: Renderer) end


-- Return a factory function that Rive uses to build the Node instance.
return function(): Node<MyNode>
  return {
    init = init,
    advance = advance,
    update = update,
    draw = draw,
  }
end

Perfect! Next, let's hook up the particle artboard to the script.

Connecting the Artboard to the Script

Right now, the script doesn't have access to any artboards, so we'll need to set that up. To do this, we'll add an artboard input to the script and connect it directly to the particle artboard.

In the inputs section of the script, add a new artboard input. Set its property to Input and specify the type as Artboard.

-- Define the script's data and inputs.
type MyNode = {
  particle: Input<Artboard>,
}

[...]

If the syntax looks unfamiliar, Rive's official scripting tutorials cover this in detail.

Every input we declare must also be initialized. Scroll down to the code section where all variables are initialized and add this new input there as well. Here, we'll reference the particle input and set its value to late, which tells Rive that the value will be supplied from outside the script rather than defined internally.

[...]

-- Return a factory function that Rive uses to build the Node instance.
return function(): Node<MyNode>
  return {
    init = init,
    advance = advance,
    update = update,
    draw = draw,
    particle = late(),
  }
end

After saving the script, a new artboard input will appear in the script's properties panel, ready to be assigned. When you open it, you'll be able to select the Particle component.

<StaticHalfWidthRemoteImage src="/issues/issue68/assigning-artboard-script.webp" alt="Assigning the Particle artboard to the script." link="/issues/issue68/assigning-artboard-script.webp" caption="Assigning the Particle artboard to the script." />

The next step is to use the draw and advance functions to render the script on screen. The advance function runs every frame and updates the animation logic while draw runs after that and renders the element to the screen.

So, let's use self to access the particle input we created and then call the draw function on it.

[...]

-- Called every frame (after advance) to render the content.
function draw(self: MyNode, renderer: Renderer) 
  self.particle:draw(renderer)
end

[...]

After this, we'll use the AI agent to handle the code and the more complex logic.

Next, let's update the advance function. We'll use self again to access the particle input, call its advance function and pass in the seconds value.

[...]

-- Called every frame to advance the simulation.
-- 'seconds' is the elapsed time since the previous frame.
function advance(self: MyNode, seconds: number): boolean
  self.particle:advance(seconds)
  return false
end

[...]

Once saved, we should now see the particle on screen.

<StaticHalfWidthRemoteImage src="/issues/issue68/draw.webp" alt="Selecting the Particle artboard." link="/issues/issue68/draw.webp" caption="Selecting the Particle artboard." />

Setting the Artboard's width and height

Next, we want the particle to travel from the top of the artboard all the way to the bottom. To make this happen, the script needs to be aware of the artboard's dimensions.

So, we'll add two numeric inputs to represent the artboard's width and height.

-- Define the script's data and inputs.
type MyNode = {
  particle: Input<Artboard>,
  screenWidth: Input<number>,
  screenHeight: Input<number>,
}

[...]

After that, we'll initialize these values.

[...]

-- Return a factory function that Rive uses to build the Node instance.
return function(): Node<MyNode>
  return {
    init = init,
    advance = advance,
    update = update,
    draw = draw,
    particle = late(),
    screenWidth = 850,
    screenHeight = 1650,
  }
end

Once the script is saved, we'll see two new input fields appear. Now we can move on to the fun part, working with the AI Agent!

We'll use the agent to animate the particle, create duplicates, and trigger various actions, allowing us to build a fully dynamic particle system using nothing but scripting.

Building the Falling Animation with the AI Agent

To begin, we'll use a simple prompt just to confirm everything is set up correctly. In this case, we'll tell the script to position the particles at the exact center of the screen.

To interact with the agent, open the agent tab and enter a prompt. Here's the one I used:

Modify the existing 'CoffeeParticlesFactory' script.

Center the Particle artboard in the middle of the screen.

Use the existing variables:
- screenWidth
- screenHeight

Set the Particle position so it is centered on both X and Y based on these values.

With that, we've created our first bit of logic using the AI agent.

Below is the script generated by the AI agent:

[...]

-- Called every frame (after advance) to render the content.
function draw(self: MyNode, renderer: Renderer)
  -- Center the particle artboard on the screen
  renderer:save()
  renderer:transform(
    Mat2D.withTranslation(self.screenWidth / 2, self.screenHeight / 2)
  )
  self.particle:draw(renderer)
  renderer:restore()
end

[...]

Now, let's build a single animation for the particle. We'll tell the agent to generate a looping animation where the particle begins just above the top edge of the screen.

From there, it will fall all the way to the bottom over a duration of 3 seconds. Once it reaches the bottom, the animation finishes and instantly starts over, looping endlessly.

Here is the second prompt:

Add a looping falling animation to the Particle artboard.

Requirements:
- The animation should loop continuously.
- Duration: 3 seconds.
- Start the particle above the top edge of the screen (outside bounds).
- End the particle below the bottom edge of the screen (outside bounds).
- Use ease in for the motion.
- When the animation loops, the particle should jump back to the starting position above the screen, without visible popping.

Here is the animation when played:

<StaticHalfWidthRemoteImage src="/issues/issue68/particle-loop.gif" alt="Playing the particle looping animation." link="/issues/issue68/particle-loop.gif" caption="Playing the particle looping animation." />

Now that we have a single animation in place, let's duplicate it and transform it into a full particle effect.

Building a Particle Effect

To make this more dynamic, we'll introduce inputs that let us control the number of particles displayed on the screen and randomize their initial positions so they're evenly distributed rather than clustered together. We'll also stagger the animation so the particles begin falling at different moments.

First, create a new input named particlesCount and set its initial value to 10.

-- Define the script's data and inputs.
type MyNode = {
  particle: Input<Artboard>,
  screenWidth: Input<number>,
  screenHeight: Input<number>,
  [...]
  particlesCount: Input<number>,
}

[...]

-- Return a factory function that Rive uses to build the Node instance.
return function(): Node<MyNode>
  return {
    init = init,
    advance = advance,
    update = update,
    draw = draw,
    particle = late(),
    screenWidth = 500,
    screenHeight = 500,
    [...]
    particlesCount = 10,
  }
end

Next, we'll move to the agent and tell it to duplicate the particle artboard according to the particlesCount input we just added. We'll also have it assign a random X and Y position to each particle, ensuring they're scattered across the screen instead of dropping along a single path.

Here is the prompt I used:

Modify the existing 'CoffeeParticlesFactory' script to spawn multiple particles based on 'particlesCount'.

Requirements:
- Create 'particlesCount' particles (instances) of the Particle artboard.
- Each particle should use the existing falling animation with a loop duration of 3 seconds.
- For each particle, randomize a different X position across the screen width.
- Randomize a different Y offset so particles start at different times (staggered, not synchronized).

Loop behavior:
- When a particle exits the bottom of the screen (end of the 3s loop), reset it to the top (outside bounds) and re-randomize its X position so the falling pattern keeps changing over time.

Keep everything else unchanged.

At this point, the single particle we designed is replicated into multiple particles. The end result is a simple falling animation made up of 10 individual particles.

<StaticHalfWidthRemoteImage src="/issues/issue68/falling-particles-animation.gif" alt="Playing the falling particles animation." link="/issues/issue68/falling-particles-animation.gif" caption="Playing the falling particles animation." />

If you're curious, I've made this animation available on the Rive Marketplace, where you can check it out here.

Adding the Animation to the App

Before the app can use the animation, it needs to be exported. To do this, select Export > For runtime. This generates a .riv file, which I'll name particles.riv.

Next, I created a view and initialize a RiveViewModel using the exported Rive file.

This is what the view implementation looks like:

import RiveRuntime
import SwiftUI

struct ScriptingView: View {
    @State private var vm: RiveViewModel?

    var body: some View {
        ZStack {
            Group {
                if let vm = vm {
                    vm.view()
                        .frame(maxWidth: .infinity, maxHeight: .infinity)
                        .ignoresSafeArea()
                } else {
                    VStack {
                        Text("Missing .riv file")
                            .font(.headline)
                        Text("Add `particles.riv` to the app target (Copy Bundle Resources), then rebuild.")
                            .font(.subheadline)
                            .foregroundStyle(.secondary)
                            .multilineTextAlignment(.center)
                    }
                    .padding()
                }
            }
        }
        .navigationTitle("Scripting")
        .onAppear {
            // avoid RiveRuntime fatalError in SwiftUI previews when the resource isn't bundled yet.
            if Bundle.main.url(forResource: "particles", withExtension: "riv") != nil {
                vm = RiveViewModel(fileName: "particles")
            }
        }
    }
}

Rive Scripting is supported in the Rive iOS runtime starting from version 6.13.0, so be sure you're on that version or newer. Anything older won't work. Speaking from experience ... I learned that the hard way 🙂

And here's the final outcome:

<StaticHalfWidthRemoteImage src="/issues/issue68/app-with-scripting.gif" alt="Playing the particle looping animation in the app." link="/issues/issue68/app-with-scripting.gif" caption="Playing the particle looping animation in the app." />

In case you are interested in the source code, feel free to check out the repository.

🤝 Wrapping Up

Rive Scripting was recently made available to everyone, and I wanted to dive into it and share a beginner-friendly overview with you. It's definitely a powerful on-ramp for designers and a speed boost for developers!

You can build fully interactive animations without needing any programming background. That brings the "Start building with Rive for iOS" series to a close!

I hope you enjoyed it as much as I did 😃

References

• Scripting: Getting started
• Scripting documentation
• AI Coding Agent FAQ
• Why Scripting runs on Luau
• How to Build Dynamic Particle System in Rive Using Scripting & AI Agent

Last week, we carried on with our "Start building with Rive for iOS" series and wrapped up part 2.

If you haven't had a chance to read it yet, I recommend checking it out first to get the most value from the series.

Now, we're moving on to part 3, where we'll explore topics like rendering dynamic content, supporting multiple languages in Rive animations, and efficiently managing assets.

The Plan

In this edition, I'll guide you through the mechanics of data binding with Rive View Models, show how to load and apply fonts to animations and explain how to implement fallback fonts that Rive can rely on when the main font lacks certain characters. We'll follow this approach:

• 🎸 Understanding data binding in Rive
• ✍️ Loading and applying fonts to Rive animations
• 🧘‍♀️ Adding Support for Fallback Fonts in Rive

<RenderRelatedWork nextWorkUrl="/issue/issue67-data-binding" nextWorkTitle="🎸 Understanding Data Binding in Rive" />

Last week we kicked of the "Start building with Rive for iOS" newsletter series. This time, we move to the part 2 of the series to explore how to build state-driven experiences with Rive on iOS.

The Plan

In this edition, I'll walk you through the fundamentals of Rive's Apple runtime library, show how to set up a RiveViewModel in both SwiftUI and UIKit, and wrap up this week's issue with a step-by-step build of a custom animated tab bar driven by Rive animations. Below is the approach we'll follow:

• 🏄🏻‍♂️ Getting started with Rive in SwiftUI
• 🙌 Getting started with Rive in UIKit
• 🎮 Custom animated tab bar driven by Rive animations

<RenderRelatedWork nextWorkUrl="/issue/issue66-swiftui" nextWorkTitle="🏄🏻‍♂️ Getting started with Rive in SwiftUI" />

Recently, our design team at work has been advocating for the use of polished, fluid animations built with Rive. I happened to be the one tasked with exploring it, so I dove in, learning the tool, experimenting with it, and creating a few prototype projects along the way.

That inspired me to start a new series in the newsletter called "Start building with Rive for iOS" that I want to share with you!

The content is directly inspired by the challenges I faced integrating Rive into a production iOS app: state handling, view model coordination, dynamic asset configuration, performance considerations, and more.

Each edition builds on the previous, moving from foundational concepts to more advanced, real-app use cases. By the end of the series, we'll have put together a fully animated iOS app powered by Rive.

Series Plan

This will be a 4-part deep dive into using Rive on iOS. Here's the high-level plan:

• Edition 1 - Foundations & App Narrative Setup
  • Introduction to Rive and its role in a modern SwiftUI/UIKit architecture
• Edition 2 - State-Driven Experiences (SwiftUI + UIKit)
  • Getting started with Rive's Apple runtime
  • Implementing a RiveViewModel
  • Coordinating Rive State Machines with SwiftUI and UIKit state
  • Building a custom animated tab bar driven by Rive animations
• Edition 3 - Dynamic Content, Localization, and Scalable Asset Strategy
  • Supporting multiple languages using Xcode String Catalogs and Rive bindings
  • Loading and applying fonts programmatically with the Rive iOS runtime, including fallback font support
• Edition 4: Advanced Workflows with Rive Scripting + AI Agent
  • Creating a Rive Script that coordinates the animation layers and state machines
  • Improving animation logic using the AI coding agent
  • Integrating the script-driven animation into the app and connecting it with live data

Rive Overview

Rive is an interactive motion platform where you can code, design, and animate in one collaborative editor. Instead of exporting frame-by-frame animations or videos, Rive uses vector graphics and state machines to create animations that can react instantly to user input and application state, while running them natively inside iOS apps.

In a modern iOS stack, Rive fits naturally alongside SwiftUI and UIKit as a dedicated layer for motion and interaction. Designers author animations and logic in the Rive editor, export a single .riv file, and developers integrate it using one of the available Rive runtimes.

The next edition will cover more about the Apple runtime for iOS. Until then, feel free to take a look at the documentation.

At runtime, animations are rendered efficiently using Metal, scale cleanly across device sizes, and can be driven directly from Swift code.

For SwiftUI apps, Rive works as an interactive view that can be bound to state, making animations a first-class part of a declarative UI.

In UIKit, Rive views integrate just like any other UIView, responding to gestures, control events, and view lifecycle changes.

This makes Rive a strong complement to native iOS animations, handling complex, interactive motion while keeping SwiftUI and UIKit focused on layout, state, and navigation.

🤝 Wrapping Up

Rive brings together an interactive design platform, a powerful state-based graphics format, a lightweight cross-platform runtime, and an extremely fast rendering engine.

In the next edition, we'll move on to part 2 of the series and explore how to build state-driven experiences with Rive on iOS. Stay tuned!

Have a great week ahead 🤎

As we kick off a new year, I'd like to take a moment to look back at 2025 and share a glimpse of what's ahead in 2026! The past year has been both busy and fulfilling. I launched a brand-new app and continued documenting and sharing my learnings through newsletter editions.

Thank you for being part of the journey and for supporting my work throughout the year 🙏.

Year Highlights

2025 was a big year me:

• 23.7k unique visitors to the site.
• 36 newsletter issues were published.
• 2 new focused series covering popular iOS topics were released.
• A new app, Coffee Break News, was launched - built alongside the newsletter series "Building a Newsletter App".

Top Issues

• Bringing App Intents to Your SwiftUI App
• Introducing Unit Tests with Swift Testing
• Top WWDC Reads from the iOS Community
• Creating an App Icon with Zero Design Skills
• Using ImageRenderer in SwiftUI
• Identifying Hangs in iOS Apps

What's coming in 2026

This year will follow a similar rhythm to 2025. I'll continue publishing bi-weekly, writing about what I'm currently working on or iOS topics that catch my interest.

In 2025, AI features moved from "nice demos" to essential functionality. Because of that, I plan to commit some editions to AI-powered features using Apple Foundation Models.

I'll also keep expanding on topic-based series, starting from the basics and gradually increasing complexity. A brand-new series is already in the works and I will kick it off next week (hopefully), so stay tuned! 💪

I'm also hoping to attend a conference later this year. I attended Swift Leeds toward the end of 2024, and it was an experience I'd love to repeat, great connections and lots of learning.

🤝 Wrapping Up

Regarding the newsletter, I'm excited to keep the momentum going this year. I'd also like to take this moment to sincerely thank you for your ongoing support, as well as last year's sponsors, whose contributions have made it possible for me to continue my mission of delivering free, high-quality content to the community.

Wishing you plenty of great coffee moments, and I hope to see you around this year 🤎

In last week's edition, I guided you through the process of analyzing app hangs using Instruments 😰.

This week, we will pick up where we left off with the same demo app. I have intentionally included code that blocks the main thread, and we will take a closer look at what is triggering the blockage.

We will also explore how to pinpoint the specific functions in our code that can be optimized to eliminate the hang!

This guide was created using Xcode 16.4, but all instructions should remain current for Xcode 26.

Determining whether the Main Thread is Busy or Blocked

Once we have identified the hang, the next step is to check how much CPU the main thread is using:

• If the CPU usage is high, it suggests that the main thread is doing a lot of work.
• On the other hand, low CPU usage typically indicates that the main thread is probably blocked.

When you notice high CPU usage during the hang, we should investigate the tasks running on the main thread. But if the usage is low, it is more effective to focus on understanding what is preventing the thread from running, rather than what it is doing.

Explore Apple's Instruments tutorials to learn how to enhance app responsiveness, minimize memory consumption, and examine complex performance patterns over time.

<StaticImage src="/issues/issue63/main-thread-busy-or-blocked.webp" alt="Unresponsive Main Thread picture from Apple Instruments Tutorials." link="/issues/issue63/main-thread-busy-or-blocked.webp" caption="Unresponsive Main Thread picture from Apple Instruments Tutorials." />

To check this in Instruments, expand the HangApp track by clicking the small triangle to reveal its subtracks. Then, right-click on the "Severe Hang" segment in any track and select "Set Inspection Range" from the menu.

After that, click on the Main Thread track to highlight it.

The main thread is the most important thread for analyzing hangs. Instruments displays it at the top.

<StaticImage src="/issues/issue63/cpu-trace.webp" alt="Analysing the CPU Usage Trace." link="/issues/issue63/cpu-trace.webp" caption="Analysing the CPU Usage Trace." />

By examining the CPU Usage graph for the main thread during the hang, we can see that the CPU activity is minimal. This tells us that this is a blocked main thread hang.

The next step is to determine what is causing this blockage.

Enabling the Thread State Trace

To identify the root cause effectively, it is important to observe thread behavior in detail:

In Instruments, add the Thread State Trace tool by selecting it in the Instruments panel (+ Instrument > Type "Thread State Trace"). This visualization will help reveal which threads are blocked or excessively busy.

Since there isn't an existing Thread State Trace graph, we will need to run the Instruments again and reproduce the same scenario. After stopping the recording, Xcode will process the data and display the graph within Instruments, making it easier to analyze and resolve the issue.

Identifying Relevant Functions

The app hang is caused by intensive operations running on the main thread, which interferes with UI rendering and blocks user interaction. By leveraging Thread State Trace and carefully inspecting a specific portion of the timeline, we can trace the issue back to the function responsible for the hang, as illustrated in the image below:

<StaticImage src="/issues/issue63/thread-state-trace.webp" alt="Analysing the Tread State Trace." link="/issues/issue63/thread-state-trace.webp" caption="Analysing the Tread State Trace." />

Upon reviewing the Thread State Trace graph and associated logs, here is what it is telling us:

• The Instruments timeline clearly highlights a significant hang in the "Hangs" section. During this period, the main thread was unresponsive, unable to handle inputs or refresh the UI. The call stack leads us to the IssueRowView.init(issue:) method, where some resource-heavy task or delay occurred directly on the main thread, making the app stall.
• A key observation is a recorded hang lasting 501 milliseconds, aligning with a simulated delay introduced using Thread.sleep(forTimeInterval: 0.5) inside the IssueRowView.init(issue:) initializer. This confirms that this method is a primary contributor to the performance issue.

Below is the section of code that causes the thread blockage:

struct IssueRowView: View {
    let issue: Issue

    init(issue: Issue) {
        self.issue = issue
        // introduced an intentional delay that blocks the main thread
        Thread.sleep(forTimeInterval: 0.5)
    }

    var body: some View {
        [...]
    }
}

Fixing the Hang

As a straightforward demonstration, offloading the task to a background thread provides a quick and effective solution to eliminate the hang. Below is the revised init method:

struct IssueRowView: View {
    let issue: Issue

    init(issue: Issue) {
        self.issue = issue

        DispatchQueue.global(qos: .background).async {
            // Perform heavy computation on a background thread
            Thread.sleep(forTimeInterval: 0.5)
        }
    }

    var body: some View {
        [...]
    }
}

With this change in place, running the app again will show no hangs detected in Instruments, confirming that the issue has been resolved! 💪

<StaticImage src="/issues/issue63/green-trace.webp" alt="CPU Usage Trace Graph after offloading the task to a background thread." link="/issues/issue63/green-trace.webp" caption="CPU Usage Trace Graph after offloading the task to a background thread." />

This example highlights how crucial it is to perform heavy computations on a background thread to maintain responsive UI updates and prevent major freezes!

To explore the full implementation of the sample hang application, visit the repository on GitHub.

🤝 Wrapping Up

Understanding the activity on the main thread is crucial to identify and address app hangs, which is vital for delivering a smooth user experience. For this, we can use tools such as Instruments to pinpoint performance issues. Make sure intensive tasks run on background threads, and reserve the main thread exclusively for UI updates.

Following these best practices will help you create fast, responsive, and well-performing iOS apps!

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Have a great week ahead 🤎

References

• Analysing main thread activity
• Reducing main thread work by doing less
• Executing work asynchronously
• Ensuring work executes on a background thread

In this week's issue, we will dive into a common performance challenge in iOS apps: UI hangs caused by intensive tasks running on the main thread 🥵.

We will also walk through how to analyze these hangs using Instruments. To illustrate this, I have put together a demo app with deliberately added code that causes the main thread to block. The app mimics a GET request to retrieve a list of newsletter's editions.

This guide was created using Xcode 16.4, but all instructions should remain current for Xcode 26.

What is a Hang?

A UI hang occurs when the app's interface stops responding for a noticeable amount of time. This typically results from long-running operations that occupy the main thread, which is responsible for updating the UI and processing user input.

Apple strongly recommends avoiding heavy processing on the main thread. Instead, these operations should be delegated to background threads.

The Plan

In this edition, the plan is to simulate blocking the main thread with heavy computations, leading to a UI hang. Here is a quick summary:

• Simulating a UI Hang
• Identifying the Hang using Instruments

Experiencing a Hang

The demo app includes two tabs: About and Issues. The hang occurs when navigating to the Issues tab.

<StaticImage src="/issues/issue62/hang-sample.gif" alt="Experiencing a UI Hang." link="https://www.ioscoffeebreak.com/issues/issue62/hang-sample.gif" caption="Experiencing a UI Hang." priority={true} />

We'll notice that tapping on the Issues tab doesn't trigger an immediate response. It takes about 4 seconds for the app to react before it displays several rows of issues.

During this delay, not only is the Issues tab inactive, but the entire app becomes unresponsive. We can't interact with any part of the UI until the content finally loads.

Detecting a UI Hang using Instruments

In Xcode, press and hold the Run button, then select Profile from the dropdown menu.

Alternatively, we can start profiling by navigating to Product > Profile or using the shortcut (Command-I).

Once Xcode finishes building our app, it will launch Instruments with your app as the target. From the list of available templates, choose Time Profiler, then click Choose to proceed.

<StaticImage src="/issues/issue62/instruments.webp" alt="Opening Instruments in Xcode." link="/issues/issue62/instruments.webp" caption="Opening Instruments in Xcode." />

This will open a new Instruments session, preloaded with tools commonly used for analyzing time-based performance issues.

Recording a Session

Start by clicking the Record button to begin recording data. Instruments will launch your app and begin tracking its activity.

To reproduce the issue, tap on the Issues tab in the app once again. After the hang is over, stop recording.

<StaticGIF src="/issues/issue62/recording-session.gif" alt="Recording a session on Instruments." link="/issues/issue62/recording-session.gif" caption="Recording a session on Instruments." />

A large red rectangle will appear in the Hangs track, marking when the freeze began and how long it lasted.

Zooming to Inspection Range

Next, go to View > Zoom > Zoom to Inspection Range to narrow in on the relevant portion of the timeline.

Hover your cursor over the red block in the Hangs track to view a tooltip showing the precise length of the freeze. Here, we can see that the hang duration was almost 4 seconds - a Severe Hang.

<StaticGIF src="/issues/issue62/zooming-view.gif" alt="Zooming to Inspection Range on Instruments." link="/issues/issue62/zooming-view.gif" caption="Zooming to Inspection Range on Instruments." />

🤝 Wrapping Up

In this chapter, we successfully simulated a UI hang, experienced how it affects app responsiveness, and gained a better understanding of its impact on the user experience. We also captured the hang using Instruments, allowing us to measure its duration and prepare for deeper analysis.

With the hang now identified, the next step is to investigate how much CPU activity is happening on the main thread. If the CPU usage is high, it suggests the main thread is overwhelmed with tasks; if it is low, the thread might be blocked entirely.

Sounds like a solid focus for next newsletter's edition, right? 🤔

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Here is the GitHub repository link if you are interested.

Have a great week ahead 🤎

References

• Identifying a hang

Now that the spooky season has come and gone, it's the perfect time to reveal some frighteningly useful iOS tips, tricks, and treats 👻 ! Here in Portugal 🇵🇹, Halloween is slowly gaining more magic each year, but I would love to know how you celebrate it where you are!

Do your countries light up with costumes and candy, or keep things cozy, spooky and mysterious?

Let's start a new trend! Share your Halloween traditions on social media with the hashtag #iosspookyseason 🕯️🍬

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

🤖 How to write better prompts when building iOS apps

Connor recently shared a great video on what makes an effective prompt when building iOS apps with AI. He walked through an example of creating a speech journaling app using ChatGPT, showing how the quality of your prompt can make all the difference.

By comparing a vague, unstructured prompt with a clear, detailed one, Connor highlighted just how much stronger and more tailored the results can be when you give AI the right context.

If you are experimenting with AI in your apps, take a moment to be intentional with your prompts. A little clarity upfront goes a long way, saving you time, frustration, and plenty of unnecessary rework later on.

🎬 Trying out something new, sharing a glimpse into my life as an iOS engineer in Copenhagen

Last week, I came across a tweet from Monika sharing what a typical Friday looks like for her as an iOS Engineer in Copenhagen, working at Vivino, and I instantly knew it deserved a spot here in the newsletter.

It got me thinking ... how do you usually spend your days as an iOS dev? 🤔 All I know is, I definitely go through way more cups of coffee than I should! ☕️

🔥 SwiftLeeds Day One Videos Are Live!

A few days ago, Adam shared that the day-one sessions from the SwiftLeeds Conference are now live on their YouTube channel! The talks feature fantastic insights from an incredible lineup of speakers, covering everything from advanced Swift techniques to real-world app development experiences.

Whether you made it to the conference or not, these sessions are packed with gems for iOS developers at any level. Definitely worth a watch!

⬆️ Announcing the Swift SDK for Android

Over the past years, Swift has evolved tremendously, expanding its reach from cloud-based solutions to Windows programs, web apps, and even microcontrollers.

Exciting update from last week! Sharing code between iOS and Android is now far simpler! If you are building apps for both platforms, you might want to explore the new Swift SDK available for Android.

This week, I didn't have the chance to focus on the upcoming series I have been preparing 🤩, but I still wanted to share a few articles and updates that caught my attention.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

🕵🏻‍♂️ Detecting Text Language with NLLanguageRecognizer in Swift

This week, I discovered that Apple's NaturalLanguage framework offers an easy and effective method for identifying the primary language of a given text.

In Artem's latest article, you can see it in practice. He explains how NLLanguageRecognizer functions, explores its limitations, and presents a reusable LanguageDetector implementation in Swift.

🆕 What's New in the Lambda V2 Runtime

The Swift AWS Lambda Runtime V2 is now officially out of beta with version 2.0.0!

The update introduces several new capabilities including background execution for improved performance, streaming responses for real-time applications, and more. Be sure to check out Swift Toolkit's latest article and explore the sample project to see it in action!

⛔️ Certificate Pinning on iOS in Practice

This week, I came across an insightful article by Tomasz, from Bright Inventions about certificate pinning on iOS, and I wanted to share it since it is such a relevant topic in software development.

You have probably heard of man-in-the-middle attacks, but if you are new to the concept, or just want a quick refresher, this article is definitely worth a read.

​🎥 CI/CD for iOS Developers webinar recording

Last week, Pol hosted a free webinar for subscribers of the iOS CI Newsletter, covering the essentials of getting started with CI/CD and building a release pipeline for an iOS app from the ground up.

If you missed the live session or haven't had the chance to watch it yet, you can catch the recording. It is definitely worth it!

Hello all 👋! I know, I know! The past few weeks have been busy for me, and I haven't been able to write as often as I'd hoped. But this week, we are back on track!

I also want to take this chance to let you know that the newsletter will be shifting from a weekly schedule to a more occasional, likely bi-weekly or monthly. I have some new opportunities coming up, which means I'll have less time to focus to writing. That said, let's dive right into this week's topic!

If you have been keeping up with the newsletter, you probably know I have been working on a command-line tool that generates dummy data 🛠. In a previous edition, I explained how I automated its release process using GitHub Actions.

As part of my learning on GitHub Actions, I recently set up a workflow to run tests for the CLI tool. This week, I would like to walk you through that process and what I learned!

The Plan

In this edition, my plan was to set up a GitHub Actions workflow to run tests for my command-line tool. Here is what I wanted the workflow to do:

• Trigger automatically on any push or pull request to the repository main branch.
• Run Tests on a macOS environment.

Setting Up the Test Workflow

First, we need to add a workflow file in the .github/workflows directory. If that folder doesn't exist yet, go ahead and create it.

$ mkdir -p .github/workflows
$ touch .github/workflows/test.yml

Writing the GitHub Workflow

The next step is to define our workflow:

name: Run Tests

on:
  pull_request:
    branches:
      - main
  push:
    branches:
      - main

jobs:
  macos-test:
    name: Test on macOS
    runs-on: macOS-15
    timeout-minutes: 30
    env:
      DEVELOPER_DIR: /Applications/Xcode_16.2.app
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Run unit tests on macOS for Swift Package
        run: |
          set -o pipefail && xcodebuild -scheme SwiftDummyGen-Package \
            -destination "platform=macOS" test | xcpretty

Here is a quick overview of what the workflow does:

• It is triggered whenever code is pushed to the main branch or a pull request is opened targeting it.
• The first step uses the checkout action to pull the latest version of the code from the repository so it can be tested.
• We use xcodebuild to execute the tests. The -scheme option tells it which scheme to build and test while the -destination flag sets the target environment. In this case, macOS.
• In the end, we pipe the output through xcpretty to make the results cleaner and easier to read.

<StaticImage src="/issues/issue59/test-action.webp" alt="The output of the CLI tests." link="/issues/issue59/test-action.webp" caption="The output of the CLI tests." />

🤝 Wrapping Up

Using GitHub Actions to automate iOS testing simplifies our workflow by identifying issues early and frequently. This issue outlines a simple configuration that can serve as a foundation for more advanced setups, like testing across different simulators or incorporating UI tests.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

In last week's edition, I shared a Swift CLI tool that generates mock data from a Swift struct 🛠.

This week, I explored ways to automate the release pipeline for that command-line utility using GitHub Actions.

Although the project isn't open-sourced yet, it is worth noting that GitHub provides unlimited free CI/CD minutes for public repositories, making it an ideal choice for open-source development workflows 🤩.

The Plan

For this edition, I wanted to automate the release process of my dummy generator tool. The goal is to write a GitHub workflow that:

• Triggers automatically upon pushing a new tag in the repository.
• Compiles and compresses the binary on a macOS runner.
• Uploads the resulting executable to the release page.

Setting Up the Release Workflow

To get started with GitHub Actions, we will need to create a new workflow file inside our repo's .github/workflows directory.

$ mkdir -p .github/workflows
$ touch .github/workflows/release.yml

Writing the GitHub Workflow Action

The next step is to define our workflow:

name: Create Mac Release

on:
  push:
    # Sequence of patterns matched against refs/tags
    tags:
      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10

jobs:
  release-macos:
    name: Release macOS Executable
    runs-on: macos-15 

    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Build executable for release
        run: swift build -c release --arch arm64 --arch x86_64 --product SwiftDummyGen
      - name: Compress executable
        run: |
          BUILD_PATH=$(swift build -c release --arch arm64 --arch x86_64 --product SwiftDummyGen --show-bin-path)
          cp "$BUILD_PATH/SwiftDummyGen" SwiftDummyGen
          tar -czf ${{ github.ref_name }}.tar.gz -c SwiftDummyGen
      - name: Upload binaries to release
        uses: svenstaro/upload-release-action@v2
        with:
          repo_token: ${{ secrets.GITHUB_TOKEN }}
          file: ${{ github.ref_name }}.tar.gz
          tag: ${{ github.ref }}
          overwrite: true

Here is a breakdown of what is happening behind the scenes:

• We have configured the workflow to trigger on push events, specifically when a version tag following the pattern (v*.*.*) is pushed to the repository.
• To make the tool available for use, it needs to be compiled for the desired platforms. In this case, both macOS arm64 and x86_64.
• After building the binaries, we set up a GitHub release that uses the pushed tag as its identifier and included a compressed archive containing the compiled binaries.
• As illustrated in the workflow above, we can use svenstaro's upload-release-action to generate the release on GitHub.
• Be sure to commit this workflow file to your repository so it can run properly.

Adding Permissions to the Workflow

Before running the workflow, there is an important detail. In order to commit changes, the workflow needs to have write access.

To enable it, go to the repository settings, and under Actions, look for Workflow Permissions. Then, select Read and Write Permissions, and save it.

<StaticImage src="/issues/issue58/write-permissions.webp`" alt="Set write permissions to the GitHub action." src="/issues/issue58/write-permissions.webp" caption="Set write permissions to the GitHub action." />

Tagging a Release

We can create and push a new version tag directly from the terminal by running the following commands:

$ git tag v1.0.0        
$ git tag    
$ git push origin v1.0.0

Executing the Workflow

After a few moments, the workflow completes its run successfully!

<StaticImage src="/issues/issue58/completed-action.webp" alt="The action has completed successfully!" link="/issues/issue58/completed-action.webp" caption="The action has completed successfully!" />

We will find our compiled binary available as an asset on the release page! 🥳

<StaticImage src="/issues/issue58/release.webp" alt="We can find our binary in the release assets." link="/issues/issue58/release.webp" caption="We can find our binary in the release assets." />

🤝 Wrapping Up

In this edition, I walked you through setting up a GitHub Actions workflow that automatically builds and publishes your Swift command-line tools whenever a new tag is pushed to your repo.

Have a great week ahead 🤎

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

One recurring task I often find myself doing is generating dummy data, both in work-related and personal projects. While it is not particularly time-consuming, it is something I can automate to save a significant amount of time down the road.

So, this week, I put together a guide on building a command-line tool for generating dummy data using the Swift Package Manager. With SPM, creating CLI tools becomes much simpler, especially since we can build them directly in Swift.

The Plan

The plan is simple: implement a command line tool that generates dummy data from a Swift struct. Here is the approach:

• CLI tool written in Swift.
• Use ArgumentParser for:
  • input file: .swift file with a struct.
  • count: number of dummy instances to generate (with a default value of 5).
  • output file: path to Swift file for writing results.
• Parsing a single struct.
• The struct fields are limited to primitive types: String, Int, Double, Bool, Date.
• No nesting or recursive generation (maybe in the future).

Creating a command-line tool using SPM

First, we need to create a Swift executable. To create a new project, run the following in your terminal:

$ mkdir SwiftDummyGen
$ cd SwiftDummyGen
$ swift package init --type executable

<StaticImage src="/issues/issue57/tool-init.webp" alt="Creating a command-line tool" link="/issues/issue57/tool-init.webp" caption="Creating a command-line tool." />

Running the init command sets up a new package in your current directory. This includes generating a Package.swift file, where you can define your dependencies and additional targets, as well as a main.swift file, which serves as the primary script. We can rename main.swift and designate it as the entry point using the @main attribute.

@main
struct SwiftDummyGen {
    static func main() {
        print("Your command line tool starts here!")
    }
}

Adding the ArgumentParser framework for reading user input

Most command-line applications need to handle input from the user via arguments, and this tool is no different. To enable argument parsing, we will include the swift-argument-parser package as a dependency.

To integrate it, simply update your Package.swift file with the necessary configuration.

import PackageDescription

let package = Package(
    name: "SwiftDummyGen",
    platforms: [
        .macOS(.v15)
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-argument-parser", from: "1.5.0"),
        [...]
    ],
    targets: [
        .executableTarget(
            name: "SwiftDummyGen",
            dependencies: [
                .product(name: "ArgumentParser", package: "swift-argument-parser"),
                [...]
            ]
        )
    ]
)

Setting Up Property Wrappers

The SwiftDummyGen structure adopts the ParsableCommand protocol, which lets us configure the command with a brief description.

To handle user input, we use three kinds of property wrappers:

• Argument: A mandatory value the subcommand requires to run.
• Option: An optional input that can be provided by the user.
• Flag: A toggle that influences how the command behaves.

@main
struct SwiftDummyGen: ParsableCommand {
    @Argument(help: "The input Swift file with the struct definition.")
    var input: String

    @Option(name: .shortAndLong, help: "The number of dummy elements to generate.")
    var count: Int = 5

    @Option(name: .shortAndLong, help: "Writes the output to a Swift file rather than to standard output.")
    var output: String?

    static var configuration: CommandConfiguration {
        CommandConfiguration(
            commandName: "SwiftDummyGen",
            abstract: "Generates dummy data from your Swift structs."
        )
    }

    func run() throws {
        [...]

        if let output = output {
            try outputString.write(toFile: output, atomically: true, encoding: .utf8)
            print("✅ Generated dummy data written to \(output).")
        } else {
            print("\n\(outputString) \n\n✅ Generated dummy data written to standard output.")
        }
    }
}

I have intentionally skipped over the implementation specifics, as the goal here is to outline the essential steps for creating a Swift-based CLI tool.

Using Our Swift CLI Tool

At this point, we can start using our command-line tool and see what it does.

$ swift run SwiftDummyGen --help

<StaticImage src="/issues/issue57/tool-help.webp" alt="The output of the tool help command." link="/issues/issue57/tool-help.webp" caption="The output of the tool help command." />

One of the advantages of using the ArgumentParser framework is that it handles much of the heavy lifting for us. It automatically creates descriptive output similar to what we would expect from other CLI utilities. It also includes a built-in help flag, which is a standard feature in most command-line applications.

🧪 Example Usage

Say our input file is input.swift which contains the definition of a struct named Issue:

struct Issue {
    var id: String
    var content: String
    var url: String
    var title: String
    var summary: String
    var date: Date
}

Running the tool

Our command-line tool is ready to be used. Just run the following command in your terminal:

$ swift run SwiftDummyGen input.swift --count 2 --output output.swift

This generates 2 dummy issues instances and writes them to output.swift.

// Auto-generated by SwiftDummyGen.
import Foundation

struct Issue {
    var id: String
    var content: String
    var url: String
    var title: String
    var summary: String
    var date: Date
}

let dummyIssueData: [Issue] = [
    Issue(
        id: "Sample 345", 
        content: "Sample 745", 
        url: "Sample 692", 
        title: "Sample 871", 
        summary: "Sample 579", 
        date: Date(timeIntervalSinceNow: 2776)
    ),
    Issue(
        id: "Sample 310", 
        content: "Sample 362", 
        url: "Sample 213", 
        title: "Sample 309", 
        summary: "Sample 18", 
        date: Date(timeIntervalSinceNow: -221)
    )
]

The output property is optional. If it not passed, our tool will print out the results in the terminal.

Compiling as Executable

To turn your target into an executable, use the build command:

$ swift build

Once we have set up our command-line tool, the next step is to compile it for actual use. We can achieve this by building it in release mode using the -c release flag. This will generate an executable located in the .build/release directory.

$ swift build -c release

If you are curious about the exact path of the compiled binary, here is how you can find it:

$ swift build -c release --show-bin-path

To actually make use of it, we need to copy it over into the /usr/local/bin folder. Here is how we can do it:

$ cp -f .build/release/SwiftDummyGen /usr/local/bin/SwiftDummyGen

That should be enough to make our CLI tool available as a real tool!

We can now run SwiftDummyGen using your CLI tool from within any folder from the terminal! 🥳

$ SwiftDummyGen input.swift --count 2 --output output.swift

🤝 Wrapping Up

We have successfully built our own command-line tool using the Swift Package Manager. Thanks to the ArgumentParser framework, handling input arguments becomes straightforward. Once we compile a release version, the tool is ready to use wherever we need it!

Looking ahead, I plan to go further and support things like:

• Support for optional and array types (like String? and [Int])
• Add more randomization features (such as generating more realistic names)
• Add more advanced randomization (e.g. realistic names)
• Use all struct types (nested/custom)

Hope you liked it 🙂

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

This week I realized the newsletter is already a year and a half old! Still a baby 👶, but definitely but not just born.

It actually started as a monthly thing, but once I got into the flow of writing and started getting some feedback, it naturally turned into a weekly habit. Over these past 56 editions, I've covered all sorts of stuff: WWDC highlights, Apple dev tools, a tiny Swift CLI I made to pick giveaway winners, a SwiftUI navigation setup, and even an app I built in the "Building a Newsletter App" series.

Now, after all that writing, I'm taking a short break, just two weeks off while I enjoy some summer time ☀️.

While I'm away, if you've got any ideas, feedback, or just want to say hi, feel free to reach out on Twitter.

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

💪 Supercharge Your GitHub Actions with Smart Caching

Did you know you can make your GitHub Actions run faster by adding caching to your workflows?

In Nowham's latest article, you'll learn how to implement efficient caching that can save you hours every week. Plus, since GHA charges by the minute for private repositories, caching doesn't just save time but it can also reduce your compute costs.

🤖 Working with partially generated content in Xcode previews

One of the highlights of WWDC 2025 was the introduction of the Foundation Models framework.

A particularly useful feature of this framework is guided generation of Swift data structures. In the latest article by Artem, you'll explore techniques for working with partially generated content in Xcode previews, providing you a practical way to test AI-generated content.

💧 Presenting Liquid Glass sheets in SwiftUI on iOS 26

This week at work, I've been testing our app with the latest iOS beta to prepare it for iOS 26. One issue I ran into involves partial modals. They don't automatically adopt the new Liquid Glass look or its animations.

Luckily, Natalia's articles showed up just in time. In them, you'll learn how to take advantage of the new glass-style design for partial sheets in iOS 26, and how to implement smooth, morphing transitions for sheets launched from toolbar buttons using SwiftUI APIs.

Writing this newsletter every week has kind of become my happy place! It is now a regular part of my routine, a way to reflect on recent thoughts and share exciting updates from the community. It encourages me to keep up with what others are creating and gives me space to unpack my own ideas and thoughts.

I honestly didn't think it would catch on like this. But somehow ... it did. We have crossed 1,000 subscribers, with people finding it through Twitter, LinkedIn, Reddit or my website.

However, it really made me smile last week when I received direct messages from some of you suggesting topics you'd like to see covered. That really made my day. I promise I'll be exploring those ideas in upcoming editions 🤞.

As we reach the 55th edition of the newsletter, I just want to say thank you 🙏. Thank you for reading, for engaging, and for being part of this journey.

Have a great week ahead 🤎

<Banner text="CURATED FROM THE COMMUNITY" />

🔎 A Peek into My Debugging Process (With Real Examples)

I'm not sure about you, but I really missed Pol's writing.

Luckily, he's back! This time, Pol dives into his experiences with debugging real-world problems in his apps: from hidden crashes to surprising system prompts, and the tools that help him along the way!

⚡ Let's Build: Digital Rain (Matrix Code)

In a previous article of the Let's Build series, Natan by Swift Toolkit recreates the iconic Matrix Code effect in the Terminal: Digital Rain.

If you are a fan of The Matrix, this is definitely a must-read!

🚨 Detecting Device Landscape Orientation in SwiftUI

If you have been using SwiftUI, you have likely run into challenges when trying to detect device orientation.

In his latest article, Artem explores a robust method: determining orientation by examining the screen's aspect ratio with GeometryReader.

⏳ Creating amazing loading animations with SF Symbols

SF Symbols has come a long way since it was first introduced, and starting with iOS 17, it now supports advanced styling and dynamic value effects on many of its default icons.

In his latest article, Daniel shows how to leverage SF Symbols and their powerful symbol effects to build impressive loading animations in SwiftUI, without relying on complex custom code.

In last week's issue, I demonstrated how simple it is to implement text translation using Apple's new Translation framework.

This time, we'll explore how to use machine learning to detect and locate text within an image by leveraging the Vision framework. The Vision framework can do much more than find text in an image. It is also capable of isolating specific areas within images, tracking objects across image sequences, detect hand and body poses and much more!

If you have worked on projects involving QR code or barcode scanning, chances are you have already made use of the Vision framework, possibly without realizing it. As for me, my first experience with Vision came when I built a Swift command-line tool to remove backgrounds from images ✂️.

Creating a Text Recognizer

Let's begin by exploring how we can use Apple's Vision machine learning framework to extract text from images.

To get started, we'll set up a text recognition component:

import Foundation
import SwiftUI
import Vision

struct TextRecognizer {
    var recognizedText = ""
    var observations: [RecognizedTextObservation] = []

    init(imageResource: ImageResource) async {
        // Create a RecognizeTextRequest.
        var request = RecognizeTextRequest()
        // Set the request's recognitionLevel to .accurate.
        request.recognitionLevel = .accurate
        // Create a UIImage using the ImageResource.
        let image = UIImage(resource: imageResource)
        // Convert the UIImage to Data.
        if let imageData = image.pngData(),
           // The perform request can fail
           // so use try? to proceed only when results are available.
           let results = try? await request.perform(on: imageData) {
            // Store the observations that are returned by the RecognizeTextRequest.
            observations = results
        }

        // Iterate through the observations 
        // and get the top candidate of the potential text values.
        for observation in observations {
            let candidate = observation.topCandidates(1)
            if let observedText = candidate.first?.string {
                recognizedText += "\n\(observedText) "
            }
        }
    }
}

Here is a quick overview of what the code does:

• Import the SwiftUI and Vision frameworks.
• Create a RecognizeTextRequest, which is part of the Vision framework's tools for identifying text within images.
• Convert the UIImage to Data. This step is required because the RecognizeTextRequest operates on image data, not the Swift image types like UIImage.
• Use the perform method on the text request object to analyze the image and gather results. Since this involves async processing, the initializer function must be marked async to properly await the result.
• Store the observations that are returned by the RecognizeTextRequest.
• Iterate through the observations and get the top candidate of the potential text values.
• Whenever recognized text is found, we append it to the a local property.

Here is how we can integrate it into a SwiftUI view:

import SwiftUI

struct TextRecognitionView: View {
    let imageResource: ImageResource
    @State private var textRecognizer: TextRecognizer?

    var body: some View {
        List {
            Section {
                Image(imageResource)
                    .resizable()
                    .aspectRatio(contentMode: .fill)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
            }
            .listRowBackground(Color.clear)

            Section {
                Text(textRecognizer?.recognizedText ?? "")
            } header: {
                Text("Identified text from image")
            }
        }
        .navigationTitle("Text Recognition")
        .task {
            // The initializer is async
            // so you need to call it from an async function or a task.
            textRecognizer = await TextRecognizer(imageResource: imageResource)
        }
    }
}

And below is a screenshot showing the feature in action:

<StaticSmallImage src="/issues/issue54/text-recognition.webp" alt="Text Recognition from Image sample." link="/issues/issue54/text-recognition.webp" caption="Text Recognition from Image sample." />

Highlighting Found Text

Now that we have identified text in the image, the next step is to visually highlight it by drawing rectangles around the detected text areas.

To do this, we'll start by defining a struct that represents a drawable Shape.

import Foundation
import SwiftUI
import Vision

struct BoundsRect: Shape {
    let normalizedRect: NormalizedRect

    func path(in rect: CGRect) -> Path {
        // Convert the normalized coordinates to the coordinates of the image.
        let imageCoordinatesRect = normalizedRect
            .toImageCoordinates(rect.size, origin: .upperLeft)
        return Path(imageCoordinatesRect)
    }
}

Here is a quick overview of what the code does:

• Conform to the Shape Protocol.
• Import the Vision framework and define a NormalizedRect property. Each recognized text observation includes positional data indicating where the text was found within the image.
• Convert the normalized coordinates to the coordinates of the image.

Then, in our SwiftUI view, we can add an overlay to the Image to draw the BoundsRect shapes around each block of identified text.

Here is how we can do it:

struct TextRecognitionView: View {
    [...]
    let boundingColor = Color(red: 0.31, green: 0.11, blue: 0.11)

    var body: some View {
        List {
            Section {
                Image(imageResource)
                    .resizable()
                    .aspectRatio(contentMode: .fill)
                    .clipShape(RoundedRectangle(cornerRadius: 8))
                    .overlay {
                        if let observations = textRecognizer?.observations {
                            ForEach(observations, id: \.uuid) { observation in
                                // Draw a BoundsRect around 
                                // each text item observed in the image.
                                BoundsRect(normalizedRect: observation.boundingBox)
                                    .stroke(boundingColor, lineWidth: 3)
                            }
                        }
                    }
            }
            [...]
        }
    }
}

And below is a screenshot showing the text highlighting feature in action:

<StaticSmallImage src="/issues/issue54/text-locations.webp" alt="Showing the blocks of text by drawing a rectangle around each location." link="/issues/issue54/text-locations.webp" caption="Showing the blocks of text by drawing a rectangle around each location." />

🤝 Wrapping Up

The Vision framework is a powerful and versatile tool that can do much more than find text in an image. It is also capable of isolating specific areas within images, tracking objects across image sequences, detect hand and body poses and much more.

In this chapter, you have learned how to use Vision's built-in features to detect and locate text in images. This serves as a solid starting point for expanding your text recognition capabilities by incorporating more advanced functionalities.

And that wraps up the series "Get started with Machine Learning", with a high-level overview of the ML features and APIs Apple provides.

Hope you liked it 🙂

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

In the last issue of the newsletter, I introduced a new series titled "Get Started with Machine Learning", which - no surprises here 🤭 - is all about exploring various machine learning methods.

In this week's edition, I'll demonstrate how effortlessly we can implement text translation using Apple's new Translation framework. If we are working with SwiftUI, it takes just a SINGLE line of code to make it happen. Sounds too good to be true right? 😱

Read on and see for yourself! 👇

Translating Text to Another Language

Let's kick off by exploring how we can use Apple's Translation API.

To start, here is how it works:

import SwiftUI
import Translation

struct TranslationView: View {
    @State private var text = ""
    @State private var showingTranslation = false

    var body: some View {
        NavigationStack {
            List {
                Section {
                    TextField(
                        "Enter the text to translate", 
                        text: $text, 
                        axis: .vertical
                    )
                }
            }
            .navigationTitle("Translation Playground")
            .toolbar {
                ToolbarItem(placement: .bottomBar) {
                    Button("Translate") {
                        showingTranslation = true
                    }
                    .disabled(text.isEmpty)
                }
            }
            // the line that makes all possible!
            .translationPresentation(isPresented: $showingTranslation, text: text)
        }
    }
}

Here is a brief rundown of what the code accomplishes:

• We import Apple's Translation machine learning framework and apply the .translationPresentation view modifier.
• This modifier brings up a sheet that displays the original text and its detected language, lets users choose a target language, and shows the translated version of the text. It also has the ability to read the translated text out loud. You can either rely on the built-in interface to let the system handle translations for your users, or use the framework to build a more tailored translation experience.

To dive deeper into what the Translation framework can do, explore this guide.

To try it out, tap the Translate button. Experiment with different languages and use the play icon to listen to how each translation is pronounced.

<StaticImage src="/issues/issue53/translation-playground.gif" alt="Translation App Playground." link="/issues/issue53/translation-playground.gif" caption="Translation App Playground." />

P.S. Apologies if the Chinese text I pasted isn't quite right! 😅

🤝 Wrapping Up

In this edition, we explored how the Translation framework leverages machine learning to deliver powerful translation capabilities. Although it is possible to perform translations without machine learning, this framework streamlines the process, making it both easier and more effective.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Apple has recently released a set of new tutorials focused on Machine Learning, and I have been diving into them over the past few days.

As I went through the material, I noticed that a significant portion of my time was actually spent on SwiftUI, rather than the core ML content 👀 ...

That inspired me to start a new series in the newsletter called "Get started with Machine Learning". In this series, I'll be focusing specifically on the Machine Learning aspects of the tutorials, offering a high-level overview of the ML features and APIs Apple provides.

Although I'll be covering many of Apple's ML capabilities, I strongly encourage you to go through the official tutorials yourself to get the full experience 👍.

Series Plan

In this series, here is what you can expect to learn:

• How to use the Natural Language API to analyze the sentiment in text
• How to use the Vision API to identify text within an image
• How to train a machine learning model with Create ML
• How to use Core ML to integrate new models in your app
• How to use the new Foundation Models framework from iOS 26

Analyzing text

Let's kick off the series by exploring how to analyze text to identify its sentiment using the Natural Language API.

To start, here is how it works:

import NaturalLanguage

class Scorer {
    let tagger = NLTagger(tagSchemes: [.sentimentScore])

    func score(_ text: String) -> Double {
        var sentimentScore = 0.0
        tagger.string = text
        tagger.enumerateTags(
            in: text.startIndex..<text.endIndex,
            unit: .paragraph,
            scheme: .sentimentScore,
            options: []
        ) { sentimentTag, _ in
            if let sentimentString = sentimentTag?.rawValue,
                let score = Double(sentimentString) {
                sentimentScore = score
                return true
            }
            return false
        }
        return sentimentScore
    }
}

The NLTagger class allows you to specify a tagging scheme that extracts various types of information from text - such as its grammatical role or the language it is written in. Among the available schemes, we are focusing on .sentimentScore for this example. This particular scheme provides a sentiment value ranging from 1.0 (the most positive 😃) to -1.0 (the most negative 😢).

Here is an example of how to implement it:

let text = "I enjoy hard hikes. When my heart is pumping and I'm being challenged, I feel great."

let scorer = Scorer()
let score = scorer.score(text)

In this sample, the score property gets a value of 1.0, indicating extremely positive sentiment. Great! 💪

Feel free to experiment on your own by entering various types of text to see how the API reacts!

🤝 Wrapping Up

Machine learning can work across different input and output types. In this edition, we explored Apple's Natural Language framework along with sentiment analysis, demonstrating how we can input text and obtain a numerical sentiment score in return.

As a next step, we can enhance our approach by modeling sentiment characteristics, for example, defining an enum to ensure consistent representation of sentiment values throughout the app.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Running a newsletter is not an easy task 🥵! It takes a lot of time and effort, especially when you are juggling a full-time job. I am always on the lookout for ways to streamline my workflow, aiming to automate repetitive tasks that usually require my direct involvement.

One such task is keeping my newsletter repository current and ensuring that all references to it remain aligned. Recently, I set up an automated workflow that updates the README file in my newsletter repository every week. This is done using a Swift-based command-line tool and GitHub Actions.

This week, I would like to walk you through that process and what I learned from it! 👇

The Plan

In this edition, my plan was to create a command-line tool that fetches the latest issues in my newsletter and updates the README.md file with that content. To make it fully automated, I also created a GitHub workflow that runs this tool on a regular schedule. Here is the high-level plan:

• Develop a Swift command-line that:
  • Collects the most recent newsletter issues.
  • Updates a specified file (provided via the ArgumentParser) with the new data.
• Set up a GitHub Actions workflow that:
  • Executes once per week.
  • Runs the CLI tool to fetch and insert the latest content.
  • Commits and pushes any updates to the repository if there are changes.

Building the Executable

The first step involves creating a Swift command-line executable.

I won't go into the details of how to build a Swift CLI here, but if you are curious, feel free to take a look at this guide.

import ArgumentParser
import Foundation

@main
struct feedparser: AsyncParsableCommand {
    @Argument(help: "The path of the destination README file.")
    var destination: String

    func run() async throws {
        let apiClient = APIClient()

        do {
            // fetch issues from the newsletter API
            let issues = try await apiClient.getIssues()
            let latestIssues = (issues.count < 10) ? issues : Array(issues.prefix(10))
            // generate content from latest issues
            let content = MarkdownGen.makeContent(from: latestIssues)
            // write to the README.md file
            try content.write(to: URL(fileURLWithPath: destination), atomically: true, encoding: .utf8)
            print("✅ Successfully written to \(destination) file.")
        } catch let error {
            print("❌ Error: \(error)")
        }
    }
}

Here is a quick overview of what the following code does:

• The APIClient is responsible for retrieving newsletter issues, making use of Swift's async/await concurrency model.
• Then, MarkdownGen.makeContent() is called to generate the markdown-formatted string that will be written to a file.
• Finally, this content is written to a file - README.md in my case.

Setting Up the GitHub Workflow

Next, I needed to create the automation using GitHub Actions:

name: Fetch latest newsletter issues and update the README.md

on:
  push:
  schedule:
    - cron: "0 0 * * 2" # At 00:00 every Tuesday.

jobs:
  build:
    runs-on: macos-latest

    steps:
      - uses: actions/checkout@v4
      - run:  swift run feedparser README.md
      - run: |
          git config user.name henriquestiagoo
          git config user.email henriquestiago@ua.pt
          git add README.md
          git commit -m "[generated by github action workflow]: Update latest newsletter issues in `README.md` file" || echo "No changes to commit"
          git push origin main || echo "No changes to commit"

Here is a summary of the workflow setup:

• I configured the workflow to trigger both on every push and once weekly using the push and schedule triggers.
• The checkout action ensures the latest version of the code is pulled from the repository.
• After that, the CLI tool is executed to fetch the latest issues and update the README.md file.
• If there are any changes, the workflow commits those updates back to the repository.

Here is what the generated README.md looks like after the workflow has been executed:

<StaticImage src="/issues/issue51/readme-output.webp" alt="The output of my README file." link="/issues/issue51/readme-output.webp" caption="The output of my README file." />

Configuring Cirrus Runners

As a token of appreciation to Cirrus Labs for sponsoring this edition, I would like to demonstrate how you can run this workflow using the Cirrus Runners infrastructure. All it takes is updating the runs-on: property by replacing the GitHub runner with the appropriate Cirrus runner image.

name: Fetch latest newsletter issues and update the README.md

[...]

jobs:
  build:
    name: "Run on the fastest infrastructure!"
    #runs-on: macos-latest
    runs-on: ghcr.io/cirruslabs/macos-runner:sequoia

    [...]

To get started with Cirrus Runners, you need to install the Cirrus Runners GitHub App in your GitHub organization. For detailed instructions, refer to the Cirrus Runners setup guide.

And that's everything you need to do to move over to Cirrus Runners' infrastructure!

🤝 Wrapping Up

Swift CLI tools paired with GitHub Actions make for a powerful automation setup, ideal for handling repetitive or manual tasks. In this case, I have combined them to ensure my newsletter's README file is always up-to-date with the content on the website - all of this without needing input from my side.

The project is fully open-source, so if you are interested, feel free to check out the repository.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

To mark this milestone — which might seem small, but feels huge — I took a little break to explore the stunning island of São Miguel in the Açores 🏝️. Just kidding, the trip had been in the works for months!

It turned out to be a week packed with adventure: hiking trails, soaking in hot springs, and taking in some truly unforgettable scenery.

If you are a developer, here is your friendly reminder to step away from the screen every now and then. Take time off, unplug completely — your future self (and possibly your partner) will thank you for it.

That said, if you absolutely must get some tasks done, look into ways to automate them. For instance, last week's newsletter was fully prepped in advance: from going live to email sends and social media posts. I use Resend as my email provider, and their latest tools make scheduling a breeze.

Now that I am back, I have been catching up on what other devs are building with the new features and updates from WWDC 2025. If you are reading this, good news — I have handpicked several standout articles that are definitely worth your time. You will find them in this week's edition.

Happy reading!

<Banner text="CURATED FROM THE COMMUNITY" />

🤖 Using the Foundation Models Framework for On-Device AI in SwiftUI

One of the features announced at WWDC 2025 that excited me the most was the Foundation Models framework, and Artem didn't just write one — but two insightful pieces diving into it. I couldn't choose between them, so I decided to feature both!

In this article, Artem demonstrates how to ask a question and get a live, streaming reply using this on-device AI model. The framework gives developers the tools to bring on-device AI functionality into their SwiftUI apps, including real-time text generation with very little setup required — I can already spot countless use cases that could benefit from this kind of smart functionality.

🤠 Exploring the @Generable and @Guide Macros in FoundationModels

Artem's second article takes a closer look at the new @Generable and @Guide macros introduced in the Foundation Models framework. These macros simplify the process of generating structured data for particular model types by leveraging language models.

📋 WWDC 2025 Viewing Guide

In my opinion, Keith Harrison put together the most comprehensive WWDC 2025 viewing guide to help you organize and prioritize the sessions you want to catch.

If you happened to miss the Apple Platforms State of the Union or any of the sessions — or if you are simply looking for a solid recap of last week's announcements — this article is definitely worth a read!

🧑‍💻 WebView is Finally Coming to SwiftUI

Before the release of iOS, macOS, and visionOS 26, displaying web content directly within a SwiftUI app was not straightforward. Since SwiftUI didn't have a built-in WebView, we had to rely on WKWebView from UIKit or AppKit, bridging it into SwiftUI using UIViewRepresentable or NSViewRepresentable. Another option was to use third-party libraries like WebViewKit, a tool developed by Daniel a few years back.

But at WWDC 2025, Apple finally introduced a native WebView component for SwiftUI — along with other web-focused enhancements. In this article, Daniel takes a deep dive into the new WebView, showcasing how it works and providing practical code examples to help you take full advantage of this long-awaited addition.

The most exciting week of the year for iOS developers has officially wrapped up! 🥹 Between watching sessions and diving into technical write-ups, there is no shortage of opportunities to learn, experiment and get inspired!

Luckily, my team lead joined the fun and organized a full day dedicated to watching selected sessions together and sharing our takeaways. Naturally, we made sure to stock up on snacks and drinks to keep things more interesting!

<StaticImage src="/issues/issue49/team-wwdc-activity.webp" alt="Doing my best not to eat all the snacks within the first half hour." link="/issues/issue49/team-wwdc-activity.webp" caption="Doing my best not to eat all the snacks within the first half hour." />

The day turned out to be incredibly valuable — we covered nine sessions in total and had some great discussions about how to approach our upcoming sprints.

Below, I have put together some thoughts on the frameworks and features that stood out to me:

Liquid Glass

Liquid Glass is a significant new step and evolution of the look and feel of Apple Software. It introduces a flexible, dynamic layer to apps and system experiences across Apple's ecosystem of products.

It merges different visual and interface elements throught Apple's software design history:

• Aqua's tridimensional surfaces
• iOS 7's visual layers
• iPhone X's fluidity of gestures
• Dynamic Island's motion dynamics and merge behaviors.

From what I have seen, this design has received widespread criticism on social media — primarily for accessibility concerns such as poor contrast, visually overwhelming backgrounds and distracting animations.

That said, this is still a beta release, and I am confident Apple will refine and resolve these issues in the final version.

Foundation Models Framework

It is no surprise Apple delivered on-device model APIs, but the usability of the Foundation Models API genuinely impressed me! This new framework allows you to interact with an on-device Large Language Model (LLM) designed for everyday use cases. It is great for things like summarization, extraction, classification and more.

Using the model is incredibly straightforward — it takes just three lines of code. Here is one example shared in one of Apple's sessions:

import FoundationModels
  
// start a language model session.
let session = LanguageModelSession()

// provide a prompt.
let prompt = "Generate a bedtime story about a fox."
let response = try await session.respond(to: prompt)

print(response.content)

On top of that, the @Generable macro makes defining structured outputs much easier, removing the usual pain of parsing model responses and streamlining the development process.

For more on how guided generation works, check out Meet Foundation Models framework talk.

I am genuinely excited to spend more time exploring this new framework. While I expect there will be some constraints given the size of the on-device LLM, the benefits of local execution and the wide spread of use cases make it especially attractive from a developer's perspective.

SwiftUI

SwiftUI has seen significant upgrades across multiple core areas this year, such as list, scrolling behavior, performance profiling and debugging tools. The framework has also broadened what views can do — from rich text editing to 3D chart rendering, there are several exciting new view types and updates to existing ones.

One particularly welcome change is the ability to embed web content directly within SwiftUI apps. Apple has introduced a complete set of SwiftUI APIs for WebKit, including support for WebView.

Here is an example Apple highlighted during one of their sessions:

struct HikeGuideWebView: View {
	var body: some View {
		WebView(url: sunshineMountainURL)
	}
}

To learn more about all these new WebKit APIs, check session Meet WebKit for SwiftUI.

UIKit

In my opinion, the major enhancement is the built-in support for Swift Observable objects in UIKit. UIKit now integrates Swift Observation at its foundation: in update methods like layoutSubviews, it automatically tracks any Observable you reference, wires up dependencies, and invalidates the right views, without requiring you to manually call setNeedsLayout.

Here is a demonstration of automatic observation tracking in action:

// Using an Observable object and automatic observation tracking
@Observable class UnreadMessagesModel {
    var showStatus: Bool
    var statusText: String
}

class MessageListViewController: UIViewController {
    var unreadMessagesModel: UnreadMessagesModel
    var statusLabel: UILabel
    
    override func viewWillLayoutSubviews() {
        super.viewWillLayoutSubviews()

        statusLabel.alpha = unreadMessagesModel.showStatus ? 1.0 : 0.0
        statusLabel.text = unreadMessagesModel.statusText
    }
}

Swift

Swift improvements span various parts of the development workflow — from writing code to building and debugging.

A key factor in developer productivity is how fast and efficient the tools are. Swift 6.2 delivers notable performance gains, especially for projects that make use of macro-based APIs. In many cases, clean build times have been dramatically reduced — in some projects, by several minutes.

Xcode

This year, Apple is launching a new feature called Playground, designed to help you experiment with code more efficiently.

Much like previews, we can embed a playground directly within your document, and the output from running your code will be displayed in a dedicated canvas tab.

Personally, I find this tool incredibly handy — I often need to step away from full Xcode projects just to try out a snippet of code. It also offers a more straightforward approach to testing code and can help spark ideas for writing better unit tests. Here is an example:

import Playgrounds

#Playground {
    let landmark = Landmark.exampleData.first
}

🤝 Wrapping Up

Several other exciting features were announced as well, and I am eager to explore them in more depth over the coming week. I have bookmarked quite a few sessions that I haven't had a chance to watch yet 😅.

Over the next few months, I plan to dive into the new APIs and share a more in-depth look at what they offer.

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

Last week, I guided you through designing a simple app icon — starting with a placeholder, creating an initial version and refining it until it felt just right!

Now, after 11 issues in this series, it is time to bring the app to life! The next steps involve archiving the app, preparing it for the App Store and finally launching it to all users.

It has been a while since I last published Padel Time, so I revisited my own guide on the process — I recommend checking it out to follow along more easily!

The Plan

To distribute my Coffee Break News app for beta testing or public release on the App Store, I followed these steps:

• Set up a distribution provisioning profile and certificate.
• Create an App Store Connect record for the app.
• Archive and upload the app using Xcode.
• Configure the app's metadata and details in App Store Connect.
• Submit the app for review.

Configuring an iOS Distribution Profile and Certificate

To set this up, I accessed my Apple Developer account and went to "Certificates, Identifiers & Profiles". I generated an App Store Distribution Certificate, installed it in my Mac's Keychain, then created and downloaded a matching Distribution Provisioning Profile. After that, I integrated both into Xcode for proper code signing.

Here is how my "Signing & Capabilities" settings look in Xcode:

<StaticImage src="/issues/issue48/provision_profiles.webp" alt="Choosing the iOS provision profile for production." link="/issues/issue48/provision_profiles.webp" caption="Choosing the iOS provision profile for production." />

Setting Up an App Store Connect Entry

To register the app, I logged into App Store Connect, navigated to "My Apps", and selected "New App". I then filled in essential details like the app name, primary language, bundle ID, and SKU.

Here is my App Store Connect entry:

<StaticHalfWidthImage src="/issues/issue48/new_app_record_app_store_connect.webp" alt="Creating an app record in App Store Connect." link="/issues/issue48/new_app_record_app_store_connect.webp" caption="Creating an app record in App Store Connect." />

Archiving and Uploading the app with Xcode

To package and submit the app using Xcode, I followed these steps:

• Opened "Product" > "Archive" to generate an archive.
• Selected the archive and clicked "Distribute App", choosing "App Store Connect".
• Completed the validation, code signing, and upload process.

Here is my archive, prepped for distribution:

<StaticImage src="/issues/issue48/archive_xcode.webp" alt="Archiving the app in Xcode." link="/issues/issue48/archive_xcode.webp" caption="Archiving the app in Xcode." />

Configuring App Metadata in App Store Connect

In App Store Connect, under the "App Store" tab, I needed to enter key details in the "App Information" section, such as supported languages, categories, and my app's privacy policy URL. Next, I uploaded screenshots and added important metadata, including the app description, keywords, support URL, and marketing URL.

Here are my app previews and screenshots that will be displayed on the App Store:

<Images3Grid src="/issues/issue48/app_store_1.webp" alt="App Store screenshot 1." link="/issues/issue48/app_store_1.webp" caption="App Store screenshot 1." src2="/issues/issue48/app_store_2.webp" alt2="App Store screenshot 2." link2="/issues/issue48/app_store_2.webp" caption2="App Store screenshot 2." src3="/issues/issue48/app_store_3.webp" alt3="App Store screenshot 3." link3="/issues/issue48/app_store_3.webp" caption3="App Store screenshot 3." />

I use Framous from Charlie Chapman to add device frames to my screenshots — highly recommended for quick, polished results!

Submitting the App for Review

To submit my app for review, I navigated to the "Build" section in App Store Connect and selected "Select a build before you submit your app". After picking the uploaded build from Xcode, I clicked Done, then Save, and finally Submit for Review. After that, Apple reviewed and approved the app!

🤝 Wrapping Up

I am thrilled to announce it is now live — go check it out and let me know your thoughts! What are you waiting for? Get the App now! 🚀

Have any feedback, suggestions, or ideas to share? Feel free to reach out to me on Twitter.

<Banner text="CURATED FROM THE COMMUNITY" />

📖 Terminal Setup & Scripts

Recently, Noam had to configure a new machine, which led him to revisit his terminal setup. Fortunately for us, he took the time to document his own terminal configuration — including the aliases, commands and theme he relies on daily.

You can start with the simple aliases and essential functions, and slowly expand your setup from there. Your future self will appreciate it!

🔀 Navigation Coordination in SwiftUI

A while back, I published a blog post about SwiftUI navigation, where I refactored an older navigation layer to adopt the Coordinator Pattern. Not long after that, Stephen came across my post, reached out for a quick chat and decided to spin up a sandbox project to explore the idea further.

My original implementation had a few limitations — for instance, it didn't allow child coordinators to manage the parent's navigation path and the navigation logic wasn't fully decoupled from the views, among other things. Stephen took the concept, enhanced it significantly, and this week, he open-sourced his new version - NavigationCoordination in SwiftUI.

This kind of collab highlights one of the great advantages of sharing your work publicly: with a bit of luck, you can spark ✨ interest in other devs, who may even build upon and improve your ideas! In case of doubt, do it! 💪

Last week, I walked you through the process of localizing my newsletter app using a String Catalog, enabling support for two languages: English and Portuguese.

As the app evolves, one thing that keeps catching my eye is the blank placeholder icon. Hiring a designer is always an option, but if you are on a budget or just enjoy learning, why not try creating one yourself? 😉

This week, I will walk you through designing a simple app icon — even if you have zero design experience like me!

The Plan

As developers, designing app icons should be on the bottom of our priorities. Yet, here we are, so here is the plan for crafting a version of our app icon:

• Creating a placeholder App Icon
• Understand the key principles for designing better app icons
• Creating the first version of your app icon
• Tweaking the design until it feels right

Creating a Placeholder App Icon

As I mentioned earlier, the default blank placeholder icon bothers me. But it doesn't have to stay that way! With AI tools, you can generate a simple app icon by providing a prompt.

Personally, I like using Bakery, a macOS app by Jordi Bruin, to quickly create a placeholder icon. Just pick a background color and a symbol or emoji and the app generates a preview. If you are happy with it, simply drag and drop it into Xcode.

Here is the placeholder version of my app icon.

<StaticSmallImage src="/issues/issue47/placeholder_app_icon.webp" alt="Using the Bakery App to get an app icon placeholder." link="/issues/issue47/placeholder_app_icon.webp" caption="Using the Bakery App to get an app icon placeholder." />

Not bad right? Yet, I believe I can do better!

Understand the Key Principles for Designing Better App Icons

I am no design expert, but I have learned some essential principles from Flora Damiano, who gave a great talk at Swift Leeds 2024 on crafting app icons.

Here are the key aspects to focus on. Make your app icon:

• Versatile: Keep you icon legible at every size on every device you are developing for
• Consistent: Your icon should resemble your App's identity
• Original: Use color and shape to convey your App's soul in a unique way
• Memorable: Create an emotional connection with the user of your App

Creating the First Version of Your App Icon

I use Sketch to prototype my app icons, but you can achieve similar results with any design tool of your choice. If you are new to Sketch, I recommend checking out their guides and courses to learn the basics.

Your icon should be designed at the proper resolution to be implemented in Xcode. In iOS and macOS, for example, the icon has to be sized at 1024x1024px.

Once the icon is designed, it needs to be exported in multiple sizes and resolutions. Thankfully, Apple's Design Resources provide free Sketch and Photoshop templates. Simply insert your icon, and the tool will generate all necessary assets for Xcode.

You can grab the app icon Sketch template from Apple's Design Resources. In this guide, you can see how to open the template in Sketch.

iOS Coffee Break Newsletter Sticker

At Swift Leeds 2024, I ran a marketing campaign for the newsletter by sharing stickers with fellow developers. That gave me a solid starting point for my app icon design. Here is the initial version:

<StaticHalfWidthImage src="/issues/issue47/ioscoffeebreak_starter.webp" alt="iOS Coffee Break App starter app icon" link="/issues/issue47/ioscoffeebreak_starter.webp" caption="iOS Coffee Break App starter app icon." />

While I like how the icon looks, there is a major issue — the lettering isn't readable on a iPhone/iPad screen. Unfortunately, that means this version won't work!

Tweaking the design until it feels right!

After creating the first version of my icon, I realized the lettering had to go — it just wasn't working. Additionally, the background color needed more contrast with the coffee cup to improve visibility. So, I explored with different color variations and adjustments until I landed on a final version that I was happy with! 🙂

<StaticHalfWidthImage src="/issues/issue47/ioscoffeebreak_final.webp" alt="iOS Coffee Break App final app icon" link="/issues/issue47/ioscoffeebreak_final.webp" caption="iOS Coffee Break App final app icon." />

🤝 Wrapping Up

I can't way to share the app with you! I am almost there, I promise! But before that, I need to set up everything in the App Store to make it available for users.

In the next couple of weeks, I plan to walk you through the process of publishing an app to the App Store. Stay tuned!

Last week, I showed you how to handle deep links from notifications in my newsletter app, ensuring users land on the issue detail page when tapping push notifications of a certain type.

This week, I will guide you through localizing the newsletter app using a String Catalog! Localization is key to making your app accessible to a global audience.

Before Xcode 15, managing translations with multiple .strings and .stringsdict files was tedious and error-prone. Mistakes could easily break your build. Now, with Xcode 15 or higher, Apple has introduced String Catalogs, a streamlined and user-friendly way to handle localization efficiently. Let's explore how to use this powerful new tool to make your app speak different languages!

The Plan

The goal is to localize the app into English and Portuguese, but the process applies to any language. Here is the plan:

• Add a String Catalog to the project
• Include new languages in the project settings
• Add localizable text to the catalog
• Handle pluralization for different cases

Adding a String Catalog to the Project

To add a string catalog to your project, go to File > New > File from Template. In the pop-up window, select your platform, type "string catalog" in the search bar, choose String Catalog, and click Next. You can keep the default name as Localizable. Pick a save location, and click Create to finalize.

<StaticImage src="/issues/issue46/add_string_catalog.webp" alt="Adding a string catalog to the project." link="/issues/issue46/add_string_catalog.webp" caption="Adding a string catalog to the project." />

Adding a Language to your Project

To make the app support multiple languages, you need to add additional languages to your project. Select the string catalog in the Project Navigator, then click the (+) button at the bottom of the string catalog editor and choose the language you want to include. In my case, I am adding Portuguese as the additional language.

<StaticImage src="/issues/issue46/add_language.webp" alt="Adding a language to the project." link="/issues/issue46/add_language.webp" caption="Adding a language to the project." />

Adding the Localizable text to the String Catalog

Xcode keeps your string catalog updated with your app's localizable content each time you build the project. To populate it, go to Product > Build, and Xcode will automatically detect and add localizable strings.

<StaticImage src="/issues/issue46/adding_translations.webp" alt="Adding localizable text to the string catalog." link="/issues/issue46/adding_translations.webp" caption="Adding localizable text to the string catalog." />

You can monitor the translation progress for each language by checking the indicator next to its name in the String Catalog.

Adding Pluralizations

String catalog simplifies the localization of word variations. Pluralization is now easier than ever - just right, click a row and select "Vary by Plural", which adds One and Other options.

<StaticImage src="/issues/issue46/vary_plural.webp" alt="Varying a string by plural." link="/issues/issue46/vary_plural.webp" caption="Varying a string by plural." />

You can also vary text based on the device type, which is especially useful when supporting multiple platforms.

🤝 Wrapping Up

That is a wrap on this week's issue, where I explored localization with Xcode String Catalogs. I truly believe String Catalogs are a well-designed addition that transforms the once tedious localization process into something much more streamlined and enjoyable to use!

Next week, I will be stepping out of my comfort zone to explore how to design an app logo for my newsletter app, without any prior design skills. Stay tuned!

Last week, I walked you through integrating push notifications into my newsletter app and configured a provider to send them!

This week, I am taking things further by handling deep linking from notifications. I will show you how to direct users to a specific screen when they tap a notification. By default, the app opens on the initial screen, but I want users to land on the latest issue instead - let's make that happen today!

🧐 Sneak Peek: Handling Deep Links

Here is a glimpse of what I am aiming for - handling deep links from push notifications!

<StaticHalfWidthImage src="/issues/issue45/deep_links.gif" alt="Example of handling deep links from a push notification." link="/issues/issue45/deep_links.gif" caption="Example of handling deep links from a push notification." />

The Plan

The goal is simple - handle a deep link when I click on a notification. Here is the plan:

• Configure a custom URL type
• Understand how to create an Apple notification JSON payload
• Get the data from the notification
• Link the app's entry point with the AppDelegate
• Handle deep links from the notification JSON payload

Configuring a custom URL Type

To set up deep links within our Xcode project, we need to configure a custom URL scheme. To do that, click on your project > Info Tab > Select URL types > click the "+" icon. Here, we need to fill the identifier and the URL scheme fields. The identifier corresponds to your app bundle identifier and the URL schemes is essentially the host part of your app that this is going to listen to and it can be a string you choose. In my case, I am going with ioscoffeebreakapp as my URL scheme.

Here is my configuration as example:

<StaticImage src="/issues/issue45/url_schemes.webp" alt="Setting up an URL type in Xcode." link="/issues/issue45/url_schemes.webp" caption="Setting up an URL type in Xcode" />

Creating the JSON payload

Here is how you can create an Apple notification JSON payload:

{
    "aps" : {
       "alert" : {
            "title" : "New Issue is live 🚀🚀🚀",
            "body" : "Check issue #45 and learn how to handle deep links."
        },
        "sound" : "default"
   },
    "link": "ioscoffeebreakapp://issue?id=45"
}

For more information, check Apple's official documentation on how to generate a remote notification.

You can create custom keys such as my "link" property in the example above. I am particularly interested in providing this custom key as this property tells my application what screen it should navigate to. Here I am setting the entire deep link custom URL scheme as well as the query parameters that it expects.

Note that custom keys need to be outside of the "aps" object.

Getting the Data from the Notification Payload

Whenever we interact with a push notification, we can extract some data from it. To get the data from the JSON payload, we need to parse the userInfo dictionary from the notification content attribute.

In here, we are particularly interested in the "link" property, where we will pass the deep link information. Here is how we can do it:

extension AppDelegate: UNUserNotificationCenterDelegate {

    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse
    ) async {
        if let deepLink = response.notification.request.content.userInfo["link"] as? String,
           let url = URL(string: deepLink) {
            print("🔔 deep link: \(deepLink)")
            // handle deep link here.
        }
    }

    [...]
}

Linking the App's entry point with the AppDelegate

To link some of the functions from our SwiftUI app to our AppDelegate, we can create a property to assign our app to it. Here is one way to do it:

class AppDelegate: NSObject, UIApplicationDelegate, ObservableObject {
    var app: iOSCoffeeBreakApp?

    [...]
}

Next, in our app entry point, we can assign the app reference to the AppDelegate in the onAppear method for example.

@main
struct iOSCoffeeBreakApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate
    @State private var tabsCoordinator = TabsCoordinator()

    var body: some Scene {  
        WindowGroup {
            AppView()
                .environment(tabsCoordinator)
                .onAppear {
                    appDelegate.app = self
                }

                [...]
        }
    }
}

Handling Deep Links from the JSON Payload

Now that we have a link between the two, we can handle deep links from the userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) method.

extension AppDelegate: UNUserNotificationCenterDelegate {

    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse
    ) async {
        if let deepLink = response.notification.request.content.userInfo["link"] as? String,
           let url = URL(string: deepLink) {
            print("🔔 deep link: \(deepLink)")
            app?.handleDeeplink(from: url)
        }
    }

    [...]
}

The handleDeepLink method is defined at the app's entry point and is in charge for taking the user to the correct screen.

I will not cover the details of the TabsCoordinator in this issue but if you want to know more about how you can integrate the Coordinator Pattern into your SwiftUI Apps, I have the right article for you!

extension iOSCoffeeBreakApp {
    func handleDeeplink(from url: URL) {
        print("🔔 url: \(url)")
        let routeFinder = RouteFinder()
        if let route = routeFinder.findIssueRoute(from: url) {
            // switch to .issues tab
            tabsCoordinator.switchToTab(.issues)
            // push to route
            tabsCoordinator
                .issuesCoordinator
                .coordinator
                .push(route)
        }
    }
}

🤝 Wrapping Up

And that wraps up my guide on handling deep links using my newsletter app as an example!

Next week, I will dive into app localization, giving you an overview of Xcode's String Catalogs and how they simplify the process. Stay tuned for more!

Last week, I guided you on the implementation of the issue detail page and how I handled navigation between screens.

And this week I ask you: What is the point of an iOS Newsletter app if no one knows about new issues? If only there were a way to notify users when fresh content is available... 🤭

That's right! This week, I am setting up push notifications for my newsletter app 🚀. This is a must-have feature for an application of this kind, so I must confess I was looking forward to implement it!

In this post, I will walk through how to set up your app to receive push notifications and show how you can configure a provider to send notifications for you. Ready or not, Let's get this done!

🧐 Sneak Peek: Receiving Push Notifications

Here is a glimpse of what I am aiming for — enabling push notifications for the app!

<StaticSmallImage src="/issues/issue44/push_notifications.webp" alt="Example of receiving a background push notification." link="/issues/issue44/push_notifications.webp" caption="Example of receiving a background push notification." />

The Plan

The goal is simple — get my newsletter app ready for push notifications. Here is the plan:

• Request user permission to send notifications.
• Registering for push notifications.
• Set up a remote notification provider.

Requesting User Permission to Send Notifications

Before displaying alerts on a user's device, we must first ask their permission. This can be done by requesting authorization with the following code:

import UserNotifications

@Observable
class NotificationsManager {
    private(set) var hasPermission: Bool = false

    @MainActor
    func request() async {
        do {
            self.hasPermission = try await UNUserNotificationCenter
                .current()
                .requestAuthorization(options: [.alert, .badge, .sound])
        } catch {
            print("you can handle the error here.")
        }
    }
}

The system prompts us to allow or deny the request only the first time - any subsequent requests won't trigger the prompt again. Once we give permission, we can proceed with registering the app to receive remote push notifications.

Registering for Remote Push Notifications

We must register for remote push notifications in order to obtain the device token from APNs. In a SwiftUI app, you can do this by creating a new file called AppDelegate.swift, define a class that conforms to UIApplicationDelegate, and implement the application(_:didFinishLaunchingWithOptions:) method.

import UserNotifications

class AppDelegate: NSObject, UIApplicationDelegate, ObservableObject {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
    ) -> Bool {
        // register to receive remote notifications
        application.registerForRemoteNotifications()

        UNUserNotificationCenter.current().delegate = self
        return true
    }
}

extension AppDelegate: UNUserNotificationCenterDelegate {
    func userNotificationCenter(
        _ center: UNUserNotificationCenter,
        didReceive response: UNNotificationResponse
    ) async {
        print("You can interact with your notification here.")
    }
}

To connect the app delegate to the SwiftUI app lifecycle, we need to use the UIApplicationDelegateAdaptor property wrapper. Here is how you can do it:

import SwiftUI

@main
struct iOSCoffeeBreakApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate

    var body: some Scene {
        WindowGroup {
            AppView()
        }
    }
}

Configuring a Remote Notifications Provider

There are multiple options available for handling push notifications, including building your own provider. However, I chose Firebase because it is free, reliable, and easy to integrate. Firebase Cloud Messaging (FCM) is the feature that enables push notifications.

Here is how to set up remote notifications and integrate Firebase into your app:

• Enable the Push Notifications capability in Xcode
• Create a project in the Firebase console
• Register an iOS App to your project
• Add the Firebase SDK
• Select the FirebaseMessaging module from the firebase-ios-sdk package

In order to work with remote notifications you need to enroll in the Apple Developer Program.

Setting Up Firebase SDK

Here is how we can set up Firebase in our application's AppDelegate:

[...]
import FirebaseCore

class AppDelegate: NSObject, UIApplicationDelegate, ObservableObject {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
    ) -> Bool {        
        FirebaseApp.configure()

        [...]

        return true
    }
}

Configuring an APNs Authentication Key

To receive remote notifications on a device, our Firebase project needs to be configured with an authentication key or certificate. I am using an APNs authentication key since it doesn't expire and works indefinitely after being uploaded.

If you don't know how to create an APNs authentication key, here is one way to do it.

Once the key is created, configure it in Firebase under Project Settings > Cloud Messaging > Apple app configuration, then upload the key.

<StaticImage src="/issues/issue44/apns_key.webp" alt="Uploading an APNs authentication key." link="/issues/issue44/apns_key.webp" caption="Uploading an APNs authentication key." />

Setting Up Firebase Cloud Messaging

In order to configure our project to work with Firebase Cloud Messaging, we need to set up the messaging delegate:

[...]
import FirebaseMessaging

class AppDelegate: NSObject, UIApplicationDelegate, ObservableObject {
    func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil
    ) -> Bool {        
        [...]
        
        Messaging.messaging().delegate = self

        return true
    }
}

Next, we need to implement the Firebase MessagingDelegate protocol. This step is essential to connect our app with Firebase by sending the device token to Firebase's backend, enabling it to deliver notifications to the device.

extension AppDelegate: MessagingDelegate {
    func application(
        _ application: UIApplication,
        didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data
    ) {
        Messaging.messaging().apnsToken = deviceToken
    }
}

Remote notifications don't work on the simulator. You need an actual device to test them.

In order to test push notifications on a single device, we need to get the FCM registration token from our device. Here is how you can do that:

extension AppDelegate: MessagingDelegate {
    [...]

    func messaging(
        _ messaging: Messaging,
        didReceiveRegistrationToken fcmToken: String?
    ) {
        #if DEBUG
        print("🚨 FCM Token: \(fcmToken)")
        #endif
    }
}

Now, to create and send notifications from Firebase, just go to your Firebase console, select Messaging and then create a new push notification campaign like this:

<StaticImage src="/issues/issue44/configuring_notification.webp" alt="Sending a push notification from Firebase." link="/issues/issue44/configuring_notification.webp" caption="Sending a push notification from Firebase." />

🤝 Wrapping Up

Uff 🥵! I hope that was not a lot to follow! But with that, I have showed you how you can set up and send push notifications from Firebase to your app using my newsletter app as example.

Next week, I will be diving into handling background deep links from push notifications and navigating users directly to specific screens. Stay tuned!

⚠️ Important Update

Newsletter subscribers will receive complimentary access to the project's source code. If you want to get the most out of this series, I highly recommend subscribing! 🤩

Some weeks ago, I showed you how to test my issues view model using Apple's new Swift Testing framework.

This week, I am diving deeper into implementing the issue detail view. Simply listing all newsletter issues isn't very interesting, right? 😒 Ideally, tapping on an issue should navigate to a detailed page with more information.

In this edition, I will walk through how I built the detail view and how I handled navigation between screens. Let's explore the approach!

🧐 Sneak Peek: Issue View

I love clean and minimalist designs and I believe showing all the information in a list using sections and headers works perfectly. Here is a glimpse of what I am aiming for with the issue view.

<StaticSmallImage src="/issues/issue43/issueview.webp" alt="iOS Coffee Break app's issue detail view." link="/issues/issue43/issueview.webp" caption="iOS Coffee Break app's issue detail view." />

The Plan

To build the detail view, here are the things I need to do:

• Create the IssueView using mock data.
• Allow users to open the issue in a web browser.
• Get the articles for a given issue.
• Add sharing functionality to let users share the content.

Implement the Issue Detail View

SwiftUI's list view supports sections and headers, similar to UITableView in UIKit. To organize and structure content, you can wrap items inside a Section, optionally including a header or footer.

To allow users to open an issue in a web browser, a Link component can be added, passing the issue's URL as a string.

struct IssueView: View {
    let issue: Issue

    var body: some View {
        List {
            Section("Title") {
                Text(issue.title)
            }

            Section("Description") {
                Text(issue.summary)
            }

            Section("Info") {
                LabeledContent("Date", value: issue.date.formatted(date: .numeric, time: .omitted))
                LabeledContent("Tag", value: issue.tags.joined(separator: ", "))
            }

            if let url = URL(string: issue.url) {
                Link(destination: url) {
                    Text("Check Issue #\(issue.id)")
                }
            }
        }
        .navigationTitle("Issue #\(issue.id)")
        .navigationBarTitleDisplayMode(.inline)
    }
}

Extracting Articles from an Issue

If you take a look at the newsletter API feed, you will notice that there is no direct articles property! So, how can we retrieve them?

The API provides content_html, which contains the issue's content in markdown format. By parsing this HTML string, we can extract article links and title.

To achieve this, we need to scan the HTML, find all h2 elements and identify those containing a href attributes. For this, I have used the SwiftSoup library to efficiently scrape and parse the data.

Here is the code:

import SwiftSoup

class IssuesConverter {
    func map(from issue: Issue) -> Issue {
        guard let headers: Elements = try? SwiftSoup.parse(issue.content).select("h2") 
        else { return issue }
        var copy = issue
        var articles = [Article]()
        for header in headers.array() {
            if let link: Element = try? header.select("a").first(),
               let title = try? link.text(),
               let url = try? link.attr("href") {
                articles.append(
                    Article(
                        title: title,
                        url: url
                    )
                )
            }
        }
        copy.articles = articles
        return copy
    }
}

Add Sharing Functionality

To allow users to share issue content easily, we can use the ShareLink component in SwiftUI. Simply pass the issue's URL as a parameter, and SwiftUI will handle the sharing options seamlessly for you.

struct IssueView: View {
    let issue: Issue

    var body: some View {
        List {
            [...]
        }
        .navigationTitle("Issue #\(issue.id)")
        .navigationBarTitleDisplayMode(.inline)
        .toolbar {
            ShareLink(item: URL(string: issue.url)!)
        }
    }
}

As you can see, you can wrap the ShareLink into a .toolbar component.

Navigating to the Issue View

The final step is setting up navigation to the IssueView, which is simple. In IssuesView, use a NavigationLink component, passing IssueView as the destination.

struct IssuesView: View {
    [...]

    var body: some View {
        NavigationStack {
            Group {
                if vm.isLoading {
                    ProgressView()
                } else {
                    List(vm.issues) { issue in
                        NavigationLink {
                            IssueView(issue: issue)
                        } label: {
                            IssueRowView(issue: issue)
                        }
                    }
                }
            }
            .navigationTitle("Issues")

            [...]
        }
    }
}

🤝 Wrapping Up

With that, our issues detail view is now complete, allowing us to display information about a specific issue!

Next week, I will walk you through setting up push notifications for your app, using the iOS Coffee Break Newsletter application as an example. Stay tuned!

⚠️ Important Update

Newsletter subscribers will receive complimentary access to the project's source code. If you want to get the most out of this series, I highly recommend subscribing! 🤩

<Banner text="CURATED FROM THE COMMUNITY" />

🪟 Demystifying Picture in Picture on iOS

Adopting Picture in Picture (PiP) into a custom video player might appear straightforward at first, but if you have tried it yourself, you know that it turns out to be quite challenging!

In his latest article, Artem walks you through enabling Picture in Picture mode on iOS, beginning with a UIKit-based setup.

🤔 Sheets Manipulation

How do you manage sheets in your SwiftUI application?

Manu's latest article discusses which approach suits different situations best, enum-based vs boolean-based sheet manipulation.

🌍 Localization - Pluralizations

How do you handle String Pluralization in your app?

If you didn't know, String Catalogs come with built-in pluralization support — making it a much simpler and faster alternative to the old method using strings and stringsdict files. Some weeks ago, Manu's published an article that walks you through how to handle plurals using String Catalogs.

🧘‍♂️ Parallelize Unit Tests in Your iOS App

Noam's latest article explores two different approaches for running unit tests in your iOS application: one with the Xcode command-line tools and Bash and the other using Fastlane. Each method comes with its own advantages and drawbacks so you can choose the one that aligns best with your development process!

📜 Automate Release Notes Updates with Codemagic CI/CD

Do you find it a bit tiresome to repeatedly type out the same release notes each time you submit your app for review?

In this article, Masaki Sato from the Codemagic team shares a way to streamline that process by automatically uploading your release notes along with your app submissions to the stores.

This week, I decided to take a break from my series on how to build a newsletter app — can you believe we are already 5 episodes in? 😲

Instead, I kicked things off by trying out Antoine's tip to share my newsletter on LinkedIn, and honestly, I wish I had done it sooner! With just a few small tweaks, I was able to convert the content to fit LinkedIn's format, and the results spoke for themselves.

It might not seem like a lot, but simply resharing the content helped me grow nearly 250 new subscribers. It is a great reminder of how powerful marketing can be. You might have an amazing product, but it won't go far if people don't know about it.

Leverage your social platforms, grow your online presence — and if you are doing it right, the rest will follow naturally! 🙂

<Banner text="CURATED FROM THE COMMUNITY" />

🦉 Unit test your iOS app without Fastlane

Noam took a break on his Fastlane series to share a new post on running unit tests in your iOS app using Xcode's command-line tools and Bash.

Bash offers a ton of flexibility, and xcodebuild isn't just for testing — it can handle building, archiving, exporting, and much more. This approach is perfect if you are working in a CI environment where Ruby isn't available, can't install Fastlane, or simply want to understand how to do it all manually, without relying on third-party tools.

🕵️ How I'm using AI to improve my software engineering productivity (and why it will not steal your job)

If you are anything like Bruno, AI has become a key tool in your everyday workflow as a software engineer.

That is exactly why he decided to put together a post explaining how he is been using it in his day-to-day. He also shares his thoughts on the growing number of articles claiming AI is coming for software engineering roles.

🤖 Creating MCP Servers in Swift

New LLMs seem to pop up almost every week lately — and now there is a fresh addition to the AI automation scene: Model Context Protocol (MCP). If you have been following the AI space, chances are you have heard this acronym a few times recently.

This week, Artem took a closer look at MCP and even built a lightweight MCP server in Swift that simply returns the current Swift version installed on your machine!

🚔 React to network status updates in SwiftUI

In his latest post, Matthaus from Nil Coalescing shows how to use the NWPathMonitor as an async sequence to stream real-time network status updates directly into your SwiftUI views.

Speaking of NWPathMonitor, I created a Swift Package some time ago that also uses this API to monitor network changes - this time by leveraging the NotificationCenter to broadcast the changes. The examples I included were based on UIKit, but they are easy to tweak for use with SwiftUI too.

🍶 Sake: Swift-powered Command Management - Part I

Discover Sake – a Swift-based alternative to Makefiles. Created by Vasiliy Kotov, it lets you define your build and automation tasks using Swift code rather than traditional shell scripts.

In this practical guide, Natan from SwiftToolkit walks you through how to use Sake to streamline tasks like linting, formatting, and more – all in pure Swift.

🤔 When to choose GitHub-Hosted runners or self-hosted runners with GitHub Actions

GitHub just dropped a post on self-hosted vs GitHub-hosted runners.

With GitHub Actions, you can build out your CI/CD pipeline and automate various workflows both within and outside of GitHub. This post breaks down the key differences, benefits, and trade-offs of each option to help your team make an informed choice when it comes to scaling and securing your automation infrastructure.

Last week, I discussed implementing error handling by defining an APIError enum to represent different error types.

This week, I will demonstrate how to test my IssuesViewModel using Apple's new Swift Testing framework. This modern and expressive API simplifies writing tests while Xcode's improved interface provides clearer feedback on test results, making debugging and maintaining code more efficient.

The Plan

In a previous issue, I introduced 3 different implementations of the IssuesRepository protocol, each designed for specific scenarios. This time, I will use those implementations to test my IssuesViewModel under different conditions. Here is what I am covering in this week's issue:

• Testing the IssuesViewModel with IssuesSuccessMockRepository.
• Testing IssuesViewModel with IssuesEmptyMockRepository.
• Testing IssuesViewModel with IssuesFailureMockRepository.

Integrating Swift Testing into an Existing Project

If you are new to testing, you have nothing to compare from, however, if you are familiar with XCTest, the Swift Testing framework introduces some changes. Adding a Swift Testing based test to your project is simple. If you already have a test target, just create a new Swift file, import the Testing framework and start writing your tests.

Writing Tests for IssuesViewModel with Success Data

In this file, we will test how the IssuesViewModel behaves when our repository successfully returns data. This ensures that the view model correctly processes and presents the fetched issues.

import Testing
@testable import iOS_Coffee_Break

class IssuesViewModelSuccessRepositoryTests {
    private var issuesRepository: IssuesRepository!
    private var vm: IssuesViewModel!

    init() {
        issuesRepository = IssuesSuccessMockRepository()
        vm = IssuesViewModel(issuesRepository: issuesRepository)
    }

    deinit {
        issuesRepository = nil
        vm = nil
    }
    
    @Test("Test successful response")
    func test_successful_response() async throws {
        #expect(!vm.isLoading, "The view model should not be loading any data.")
        await vm.getIssues()
        #expect(!vm.hasError, "The view model should not have errors.")
        #expect(vm.error == nil, "The view model should not have errors.")
        #expect(vm.issues.count == 2, "There should be 2 elements within our issues array.")
        #expect(!vm.isLoading, "The view model should not be loading any data.")
    }
}

Notice the test I just showed is essentially a function with a @Test macro applied to it!

In the example above, I defined the init function within IssuesViewModelSuccessRepositoryTests. The Swift Testing framework automatically calls this function before each test, allowing us to set up necessary dependencies like a database connection or initialize mock data.

Since I am using a class-based test suite, the deinit function helps reset the IssuesRepository dependency after each test. You can think of deinit in Swift Testing as the equivalent of teardown() in XCTest, ensuring a clean test environment for every run.

Writing Tests for IssuesViewModel with Empty Data

In this file, we will verify how the issues view model behaves when our repository dependency does not return any data.

import Testing
@testable import iOS_Coffee_Break

class IssuesViewModelEmptyRepositoryTests {
    private var issuesRepository: IssuesRepository!
    private var vm: IssuesViewModel!

    init() {
        issuesRepository = IssuesEmptyMockRepository()
        vm = IssuesViewModel(issuesRepository: issuesRepository)
    }

    [...]

    @Test("Test empty response")
    func test_empty_response() async throws {
        #expect(!vm.isLoading, "The view model should not be loading any data.")
        await vm.getIssues()
        #expect(!vm.hasError, "The view model should not have errors.")
        #expect(vm.error == nil, "The view model should not have errors.")
        #expect(vm.issues.count == 0, "There should be 0 elements within our issues array.")
        #expect(!vm.isLoading, "The view model should not be loading any data.")
    }
}

Writing Tests for IssuesViewModel with Failure Scenarios

In this file, we will validate how the issues view model handles situations where the repository throws an error.

import Testing
@testable import iOS_Coffee_Break

class IssuesViewModelFailureRepositoryTests {
    private var issuesRepository: IssuesRepository!
    private var vm: IssuesViewModel!

    init() {
        issuesRepository = IssuesFailureMockRepository()
        vm = IssuesViewModel(issuesRepository: issuesRepository)
    }

    [...]

    @Test("Test failure response with .failedToDecode error")
    func test_failure_response_with_failedToDecode_error() async throws {
        #expect(!vm.isLoading, "The view model should not be loading any data.")
        await vm.getIssues()
        #expect(vm.hasError, "The view model should have errors.")
        #expect(vm.error == APIError.failedToDecode, "The view model should have an .failedToDecode APIError.")
        #expect(vm.issues.count == 0, "There should be 0 elements within our issues array.")
        #expect(!vm.isLoading, "The view model should not be loading any data.")
    }
}

Output

Each time you run the tests, the console will display a clearer and more readable output, making it easier to interpret the results:

<StaticImage src="/issues/issue41/tests_output.webp" alt="The outcome of the tests." link="/issues/issue41/tests_output.webp" caption="The outcome of the tests." />

🤝 Wrapping Up

And with that, we have seen the basics on how to implement tests using the Swift Testing framework. I personally prefer this new way of writing tests and I think it makes testing in Swift much more enjoyable and intuitive.

Next week, I am planning to implement the detail view of an issue. Stay tuned for the update!

By subscribing to the newsletter, you will get access to the code.

<Banner text={"CURATED FROM THE COMMUNITY"} />

​📦 Introducing Swiftly 1.0​

Although the latest Swift version comes included with each Xcode release, there are scenarios where you might want to install Swift separately — without using Xcode. A common case is setting up Swift on systems where Xcode is not available, like on Linux.

That is where swiftly comes in — a tool created by Apple for exactly this purpose. While it has been available for some time, Apple officially released its first stable version (1.0) just two weeks ago, now with support for macOS.

⬆️ ​Bump app version and build number using Fastlane​

Have you ever gone to submit a new TestFlight build, only to realize at the very end that you forgot to update the version or build number?

In his latest post, Noam shares how to automate this step using Fastlane. It is a super handy way to avoid those last-minute slip-ups and save time every time you push a new build.

🔍 How to inspect .ipa files and secure your iOS app from common mistakes

Do you ever wonder what is inside your favorite iOS app? Which third-party frameworks are used? What hidden resources are added to the app bundle?

In this guide, Artem walks you through inspecting .ipa files and digging into their internal contents. He also points out common security mistakes and shares three key tips to help you keep sensitive data safe. If you have never taken a look at your own app's .ipa, this article might just be the push you needed to start!

Last week, I covered how to use mock data to implement views and introduced 3 new implementations of the IssuesLiveRepository that can be used as the datasource of the IssuesView.

This week, I am diving into error handling to my network client by creating a new enum that extends Swift's built-in Error type for better error management.

The Plan

Today, I am going to focus on effectively handling errors in Swift. I will cover:

• How to declare errors
• How to throw errors
• How to catch errors
• Common error handling patterns

Creating an APIError Enum

Before I can throw an error, I need to make a list of all the possible errors I want to throw. In my case, I am interested to handle network errors.

To do this, I need to create an APIError enum that represents my type of error:

enum APIError: LocalizedError, Equatable {
    [...]

    case custom(error: Error)
    case failedToDecode
    case invalidStatusCode(statusCode: Int)
    case invalidUrl

    var errorDescription: String? {
        switch self {
        case .custom(let error):
            return "Something went wrong: \(error.localizedDescription)."
        case .failedToDecode:
            return "Failed to decode."
        case .invalidStatusCode(let statusCode):
            return "Status code falls into the wrong range: \(statusCode)."
        case .invalidUrl:
            return "URL is not valid."
        }
    }
}

Updating the APIClient

Next, I need to use the APIError and refactor the API request. Here is how my getIssues() from the APIClient now looks like:

class APIClient {
    [...]

    func getIssues() async throws -> [Issue] {
        guard let url = URL(string: "https://www.ioscoffeebreak.com/api/feed.json") else { 
            throw APIError.invalidUrl 
        }
        let request = URLRequest(url: url)
        let (data, res) = try await session.data(for: request)
        guard let res = res as? HTTPURLResponse, (200...300) ~= res.statusCode else {
            let statusCode = (res as? HTTPURLResponse)?.statusCode ?? 500
            throw APIError.invalidStatusCode(statusCode: statusCode)
        }
        let issuesResponse = try decoder.decode(IssuesResponse.self, from: data)
        return issuesResponse.issues
    }
}

Refactoring the Issues View Model

To catch a thrown error in Swift I need to use the do-catch statement. Here is how my IssuesViewModel now looks like:

@Observable
class IssuesViewModel {
    [...]

    @MainActor
    func getIssues() async {
        self.isLoading = true
        defer { self.isLoading = false }
        do {
            self.issues = try await issuesRepository.getIssues()
            self.hasError = false
            self.error = nil
        } catch let error as APIError {
            self.issues = []
            self.hasError = true
            self.error = error
        } catch {
            self.issues = []
            self.hasError = true
            self.error = .custom(error: error)
        }
    }
}

🤝 Wrapping Up

That wraps up this guide on handling errors by leveraging an enum that conforms to Swift's Error type for improved error management.

Next week, I will focus on adding unit tests to my newsletter app — covering why they matter and how to implement them effectively. Stay tuned!

<Banner text="CURATED FROM THE COMMUNITY" />

​📦 CI/CD for Swift Packages Webinar

Do you work with Swift Packages on a daily basis? Or do you happen to maintain a Swift library that is installable via SPM?

This week, Pol Piela hosted a free webinar packed with helpful tips and best practices to streamline your workflow and boost your confidence when releasing new versions of your Swift packages. If you couldn't catch it live, no worries — chances are Pol will share the recording or related resources in his newsletter. Keep an eye out!

✍️ Documenting your code with DocC

Writing clear documentation is more essential than ever, especially now that modular app architectures are becoming the norm.

Majid recently published a great article on this subject, where he walks through a simple example of how to document a function effectively.

⏳ Working with The task modifier In SwiftUI

It is often necessary to perform async tasks right when a view appears in SwiftUI. One way to handle this is by creating a Task inside the onAppear modifier's action closure — but there is a more elegant solution.

Gabriel's latest blog post dives into the task modifier in SwiftUI. It explains how to execute async code when a view appears, walks through its various configuration options, and highlights some helpful insights.

Last week, we covered how to create and use Protocols in Swift and introduced an IssuesLiveRepository that performs the work of a real external dependency within our app.

This week, I am introducing additional implementations of the IssuesRepository protocol, tailored for different use cases such as mocking and testing.

The Plan

As part of this, I will implement 3 additional versions of the IssuesRepository protocol, each designed to serve as a mock for different scenarios within our IssuesView.

• IssuesSuccessMockRepository to handle scenarios where our mocked dependency returns data.
• IssuesEmptyRepository to handle scenarios where our mocked dependency doesn't return data.
• IssuesFailureMockRepository to handle scenarios where our mocked dependency returns an error.

Creating Additional Instances of the IssuesRepository

Let's first create an IssuesSuccessMockRepository class that returns an array of sample issues.

class IssuesSuccessMockRepository: IssuesRepository {
    func getIssues() async throws -> [Issue] {
        return Issue.sample
    }
}

Next, I am creating IssuesEmptyMockRepository for the scenario that displays no issues data. Here I want to return an empty array.

class IssuesEmptyMockRepository: IssuesRepository {
    func getIssues() async throws -> [Issue] {
        return []
    }
}

Finally, I am creating IssuesFailureMockRepository and here, I am throwing an exception.

class IssuesFailureMockRepository: IssuesRepository {
    func getIssues() async throws -> [Issue] {
        throw APIError.unknownError
    }
}

Making Use of our Mocks

Using our IssuesView from previous discussions as an example, I can use the #preview macro to see how the view appears with the 3 newly implemented versions:

struct IssuesView: View {
    @State var vm: IssuesViewModel

    init(vm: IssuesViewModel = IssuesViewModel()) {
        self.vm = vm
    }

    var body: some View {
        NavigationStack {
            List(vm.issues) { issue in
                IssueRowView(issue: issue)
            }
            .navigationTitle("Issues")
            .overlay {
                if vm.issues.isEmpty {
                    ContentUnavailableView(
                        "No Issues",
                        systemImage: "books.vertical.fill",
                        description: Text("No issues have been found.")
                    )
                }
            }
            .alert(isPresented: $vm.hasError, error: vm.error) {
                Button("Retry") {
                    Task {
                        await vm.getIssues()
                    }
                }
            }
            .task {
                await self.vm.getIssues()
            }
        }
    }
}

#Preview("Happy Path") {
    IssuesView(
        vm: IssuesViewModel(
            issuesRepository: IssuesSuccessMockRepository()
        )
    )
}

#Preview("Empty Path") {
    IssuesView(
        vm: IssuesViewModel(
            issuesRepository: IssuesEmptyMockRepository()
        )
    )
}

#Preview("Unhappy Path") {
    IssuesView(
        vm: IssuesViewModel(
            issuesRepository: IssuesFailureMockRepository()
        )
    )
}

Here is the output of the IssuesView with the 3 previews:

<Images3Grid src="/issues/issue39/happy_path.webp" alt="Issues View - Happy Path." link="/issues/issue39/happy_path.webp" caption="Issues View - Happy Path." src2="/issues/issue39/empty_path.webp" alt2="Issues View - Empty Path." link2="/issues/issue39/empty_path.webp" caption2="Issues View - Empty Path." src3="/issues/issue39/unhappy_path.webp" alt3="Issues View - Unhappy Path." link3="/issues/issue39/unhappy_path.webp" caption3="Issues View - Unhappy Path." />

🤝 Wrapping Up

With that, you can see the advantages of using mocks to design views for different scenarios. Keep this approach in mind when writing your code to ensure it remains flexible and scalable.

Mock data can also be incredibly useful in testing, enabling us to write tests a lot easier, and run them faster in a more predictable way as I plan to show you on future issues! Stay tuned!

<Banner text="CURATED FROM THE COMMUNITY" />

🐼 Freeing up space on your Mac

If you are an iOS developer, chances are you have run into storage issues on your machine at some point — thank you Xcode!

This week, Manu put together a great guide on manually freeing up space on your Mac. While there are external tools that can handle this for you, I promise it is an interesting read, even if you are just curious about how Xcode eats up your storage.

🧘‍♂️ How to automate perfect screenshots for the Mac App Store

Jesse recently explored ways to automate macOS screenshots, finding far fewer options compared to iOS.

He put his findings into an article, detailing his workflow for generating Mac app screenshots with minimal manual effort. If you have faced the same challenge, be sure to check it out!

🔎 Profiling apps using Instruments

Not quite sure how to use Apple's Instruments tool yet?

Apple just released an in-depth, 1.5-hour tutorial on profiling apps with Instruments — an invaluable resource for anyone looking to get started! If you are interested but unsure where to begin, this is the perfect guide. It is definitely on my watch list!

Last week, we covered how to parse JSON using the Codable protocol and implemented a real world use case that fetches and decodes data from my newsletter API feed.

This week, I want to dive into protocols and the advantages of adopting them. As part of this, I will be refactoring my view model by replacing my APIClient by an IssuesLiveRepository class that conforms to a protocol we will define.

This will help improve flexibility, maintainability and testability in the code.

Let's explore how to implement this approach!

What is a Protocol?

In Swift, protocols act as blueprints, defining the expected behavior of a data type while ensuring consistency across code.

They have many real-world applications, such as:

• Dependency Injection: Defining interfaces for dependencies makes testing and decoupling easier.
• UI Component Design: Protocols help create reusable UI elements.
• Networking: They establish interfaces for HTTP requests, simplifying mocking and testing.
• Delegation: A key pattern in iOS, protocols define delegate responsibilities, enabling flexible communication between objects.

Defining a Protocol

Let's start by creating an IssuesRepository protocol that outlines a single method, responsible for returning an array of Issue objects. That is all we need for our example.

protocol IssuesRepository {
    func getIssues() async throws -> [Issue]
}

Conforming to the Protocol

Now, let's create an IssuesLiveRepository class that adheres to the IssuesRepository protocol. There is only one method to implement and it is the getIssues() function. Here, we call the getIssues() method from the APIClient that returns an array of issues.

class IssuesLiveRepository: IssuesRepository {
    private let apiClient: APIClient = APIClient()

    func getIssues() async throws -> [Issue] {
        return await apiClient.getIssues()
    }
}

Making use of the Protocol

In our view model, we define a property of type IssuesRepository. Using dependecy injection, we can pass in any instance that conforms to this protocol, making the code more modular, easier to test, and reducing tight coupling between components.

@Observable
class IssuesViewModel {
    private(set) var issues: [Issue] = []
    private let issuesRepository: IssuesRepository

    init(issuesRepository: IssuesRepository = IssuesLiveRepository()) {
        self.issuesRepository = issuesRepository
    }

    @MainActor
    func getIssues() async {
        do {
            self.issues = try await issuesRepository.getIssues()
        } catch {
            print("Error to be handled here: \(error)")
        }
    }
}

🤝 Wrapping Up

While protocols offer a powerful way to enhance functionality, it is essential to consider alternative approaches that might better suit specific use cases. As with many aspects of programming, there is no absolute right or wrong choice — each solution comes with its own tradeoffs.

Hopefully, this issue has provided insight into different ways to leverage protocols effectively and helped you weigh the benefits using them.

In future issues, I plan to introduce additional implementations of the IssuesRepository protocol, tailored for different use cases such as mocking and testing. Stay tuned!

References

• The Power of Protocols in Swift
• Combining protocols in Swift

<Banner text="CURATED FROM THE COMMUNITY" />

🐙 Dependency Inversion Principle (DIP) in iOS Swift

Have you come across the Dependency Inversion Principle (DIP)? If not, it is a fundamental concept in software development that helps create flexible and maintainable code.

In this article, Arifin dives into the DIP, covering its origins, the challenges of tight coupling, and various techniques for implementing it effectively in Swift.

✍️ Composing a Resume in Markdown

This week, I came across an amazing tool that I am excited to try out! Updating a resume can be a tedious task, but since it is essentially a text-based document, it can be easily automated using Markdown.

Scott wrote a insightful article explaining how to create a resume in Markdown, convert it to HTML, style it with CSS and then generate a PDF — making the entire process much more efficient!

🆗 Solving Swift Macro Trust Issues in Xcode Cloud Builds

If you have used a macro locally, you might have noticed that Xcode prompts you with a dialog asking for trust confirmation before executing the macro's package. This becomes an issue in automated setups like Xcode Cloud, where there is no way to manually approve the prompt.

In his latest article, Cihat explains how to set up a simple post-clone script to disable Xcode's macro fingerprint validation, allowing you to bypass the trust requirement.

☁️ Deploying a Swift Server App to Fly.io and Railway

For iOS developers, deploying a Server-Side Swift app can feel a bit overwhelming!

In this post, Natan from SwiftToolkit walks you through deploying a Vapor app on two platforms — Fly.io and Railway — both of which let you skip the hassle of installing Docker on your machine.

A few years back, I built a food-related 🍏🍕🍦 web API using Swift and Vapor, deploying it on Fly.io. At the time, I faced some challenges with the free tier as my sample project grew, but the deployment process was so effortless that it felt almost like cheating. Maybe I will give it another try!

If you have been following the newsletter, you should know that I have decided to build an app for it and document the process! I am glad to welcome you to the 1st issue of the "Building a Newsletter App" series!

Based on last week's survey, I now have a better understanding of what topics interest my readers the most. To kick things off, I will start with a beginner-friendly topic: parsing JSON using the Codable protocol.

As the app evolves and becomes more complex, I will introduce more advanced topics!

Hope you enjoy ✌️!

🧐 Sneak Peek: Issues View

Here is a glimpse of what I am aiming for with the issues view — a straightforward list displaying all past newsletter issues in a clean and accessible way.

<StaticSmallImage src="/issues/issue37/issues_view.webp" alt="Issues View." link="/issues/issue37/issues_view.webp" caption="Issues View." />

The Plan

Here are the steps I need to perform to get this done:

• Define the Issue struct and ensure it conforms to the Codable protocol.
• Retrieve issue data from the newsletter API feed.
• Decode the fetched data into an array of Issue objects.
• Use the decoded data to populate the view.

The Codable Protocol

The Codable protocol in Swift simplifies data conversion between Swift types and formats like JSON or XML. It merges two protocols: Encodable (for encoding Swift objects) and Decodable (for decoding external data).

By making Issue conform to Codable, we can seamlessly encode and decode instances to and from JSON, making it easy to fetch and store data in a structured format.

struct Issue: Hashable, Codable, Identifiable {
    let id: String
    let content: String
    let url: String
    let title: String
    let summary: String
    let date: Date
    let author: Author
    let tags: [String]
}

The only requirement of declaring a Codable is that all of its stored properties must also be Codable.

Mapping JSON Keys with CodingKeys

Sometimes, JSON keys don't match your Swift property names. The CodingKeys enum helps map them correctly.

struct Issue: Hashable, Codable, Identifiable {
    [...]

    enum CodingKeys: String, CodingKey {
        case id, url, title, summary, author, tags
        case content = "content_html"
        case date = "date_modified"
    }
}

If a required field is missing in the JSON, decoding will fail unless you handle it properly by providing default values or making the property optional.

Here, the content property corresponds to content_html in the JSON, and date corresponds to date_modified.

Decoding from JSON

By making custom types like Issue and Author conform to Codable, we enable encoding and decoding between Swift objects and data formats like JSON.

In this case, JSONDecoder is used to transform a JSON string into its equivalent model type in Swift.

class APIClient {
    [...]

    func getIssues() async -> [Issue] {
        guard let url = URL(string: "https://www.ioscoffeebreak.com/api/feed.json") else { return [] }
        let request = URLRequest(url: url)
        do {
            let (data, _) = try await session.data(for: request)
            let issuesResponse = try decoder.decode(IssuesResponse.self, from: data)
            return issuesResponse.issues
        } catch {
            print("Error fetching issues: \(error)")
            return []
        }
    }
}

🤝 Wrapping Up

And with that, we have covered how to conform to the Codable protocol, define CodingKeys, and implement custom decoding methods.

By understanding these concepts, you can efficiently work with your data models, ensuring consistent encoding and decoding for external formats like JSON.

<Banner text="CURATED FROM THE COMMUNITY" />

💪 The Power of Consistency: a Path to Indie Development - Pol Piella

Antoine's latest episode of the Going Indie Podcast features Pol Piella, an iOS dev and content creator I have been following for a while — especially when I need insights on CI/CD topics!

As soon as it was announced, I knew I had to highlight it in the newsletter. Pol's journey has been a huge inspiration for me in building a public profile and starting to create and share content — big kudos to him 👏!

✂️ How to remove unwanted Swift Package schemes in Xcode

I bet you have been annoyed by random package schemes being listed in your Xcode project!

In his latest article, Jesse shares a solution to clean up those unwanted Swift package schemes in Xcode. He even provides a handy script that you can integrate into your build process or run manually whenever needed!

🤝 Git Hooks in Swift

Swift as a Git Hook? Did I read that right?

In his latest post on Swift Toolkit, Natan walks through setting up Git hooks in a project. He starts with a basic bash script and then demonstrates how to implement them in Swift — both as a script and as a compiled executable.

🥶 ARCtic iOS conference 2025

If ARCtic Conference was high on your list this year but you couldn't make it, here are some good news!

Daniel has put together a special page on his blog where he shares detailed notes from each talk. It is unclear if the sessions will be publicly available, but in the meantime, you can check out his insights from the talks he enjoyed the most!

The recent newsletter issues, where I built a sample app to demonstrate iOS 18's new tab APIs, got me thinking — I really like the idea of turning the newsletter into an actual app. Would you use it? 🤔

Throughout this process, I will document everything, from the initial concept to launching it on the App Store. This way, I can reach developers of all experience levels, from beginners to seasoned professionals, while sharing insights on design and implementation.

What Should It Include?

• A complete list of all issues
• A detailed view for each issue
• A section to bookmark and access your favorite issues
• Push notifications for new issue releases
• Handling deep links
• Interactive widgets
• Additional features to be added in the future ...

Series Overview

I am sharing a form where subscribers and readers can suggest topics they would like covered in this series. Here are some of my initial ideas:

• Parsing JSON using the Codable protocol
• How to create and use protocols
• Implementing views using mock data
• Designing a scalable API client
• Using structured concurrency with async-await
• Implementing error handling
• Writing unit tests
• Persisting data with Swift Data
• Distributing the app to the App Store
• And more to come...

⚠️ Important Update

All resources will remain free, as that has been my goal from the start. Creating content takes time and effort, and it is made possible thanks to the support of sponsors. A big shoutout to Proxyman for believing in the project and sponsoring both these and upcoming issues!

However, only subscribers of the newsletter will have access to the code of this series! If you want to get the most out of this series, I highly recommend subscribing!

<Banner text="CURATED FROM THE COMMUNITY" />

🧠 Your Problem Solving Ability

"Problem solving is the foundation of software development."

This week, Manu shared an insightful article on a non-technical yet crucial topic: the importance of problem-solving. Arguably one of the most valuable skills for any developer, this article should make you dive into a moment of self-reflection. It certainly did for me!

🍓 Swift on Raspberry Pi: Building Natively and Cross Compiling

Did you know that with Swift 6, you can now compile on macOS and run directly on a Raspberry Pi — no Docker required?

This week, Natan from Swift Toolkit shared an in-depth guide covering everything from setting up the Pi to native builds and cross-compilation from a Mac. I can already imagine all the exciting projects I could run on my Raspberry Pi!

🙆‍♂️ Understanding the Liskov Substitution Principle (LSP) in Swift

Have you heard about the Liskov Substitution Principle (LSP)? If not, this principle states that objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program.

In this article, Arifin breaks down this principle and shows how to apply it in Swift, by implementing a mock and a real implementation that can be used interchangeably.

🎤 Call For Speakers

Last year, I attended Swift Leeds and it was my first-ever iOS conference experience!

If you are thinking about applying as a speaker, great news — Swift Leeds' Call for Speakers is now open until April 30th. They actively encourage new speakers, and many from last year delivered their first-ever talk at the event. This could be the perfect opportunity for you to get started!

Last week, I implemented a sample application of the newsletter to showcase how you can use iOS 18's new TabView with a sidebar in SwiftUI.

This week, I plan to rewrite last week's application using UIKit, demonstrating how to implement the same functionality for those still working with UIKit in their projects.

Let's see how to get it done!

UIKit Integration

In UIKit, managing and customizing tabs is simple:

• UITabBarController: Use the tabs property with UITab options like UISearchTab.
• Adjusting modes: Set UITabBarController.Mode.tabBar for a standard tab bar or configure it for a sidebar layout.
• SwiftUI equivalents: Convert TabSections into UITabGroup, and use sidebarActions(content:) instead of sectionActions.
• Drag and drop support: Implement UITabBarControllerDelegate to handle drag-and-drop interactions effectively.

Setting Up the Tabs

We need to create a UITabBarController and assign an array of UITab options like UISearchTab objects to its tabs property. To add a search tab, we just need to create a UISearchTab instance and add it to the tabs array.

class AppViewController: UITabBarController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Assign an array of tabs.
        self.tabs = [
            UITab(
                title: "Issues",
                image: UIImage(systemName: "book"),
                identifier: "issues"
            ) { _ in
                 // Return the view controller that the tab displays.
                 UIHostingController(rootView: IssuesView())
            },
            UITab(
                title: "About",
                image: UIImage(systemName: "person"),
                identifier: "about"
            ) { _ in
                 // Return the view controller that the tab displays.
                UIHostingController(rootView: AboutView())
            },
            // Create a search tab.
            UISearchTab { _ in
                UIHostingController(rootView: SearchArticlesView())
            }
        ]
    }
}

Integrate the Tab bar and Sidebar

To enable users to switch between a traditional tab bar and a sidebar, we can control how the system presents your tabs by configuring the mode property of the UITabBarController object.

override func viewDidLoad() {
    super.viewDidLoad()

    [...]

    // Enable the sidebar.
    self.mode = .tabSidebar
}

By default, the system presents the sidebar in landscape orientation and hides it in portrait orientation, however, you can toggle between the tab bar and sidebar in either orientation. You can also programmatically show and hide the sidebar by setting its isHidden property.

Here is the final result:

<StaticImage src="/issues/issue35/ioscoffeebreak_tabbar_sidebar_uikit.gif" alt="iOS Coffee Break Newsletter UIKit sample app." link="https://www.ioscoffeebreak.com/issues/issue35/ioscoffeebreak_tabbar_sidebar_uikit.gif" caption="iOS Coffee Break Newsletter UIKit sample app." />

To explore the full implementation of the sample application, visit the repository on GitHub.

The improvements to tabs and sidebars in iPadOS and other Apple platforms provide greater flexibility and usability for app development. Whether you are working with SwiftUI or UIKit, I am sure these updates simplify the process of building seamless, intuitive user interfaces!

<Banner text="CURATED FROM THE COMMUNITY" />

🧱 Simple Modularization Setup for a New App

Modularizing an app from the get-go has many benefits! This week, Manu shared a straightforward yet effective approach to modularizing your iOS app using Swift Package Manager's local packages that provides a good balance between structure and simplicity.

In fact, at work, we recently migrated a monolithic codebase to a modularized solution with Swift Packages, which significantly improved our build and compilation times, so I could not recommend it more!

🎸 Music recognition with ShazamKit

ShazamKit opens up exciting possibilities for integrating music recognition into your app!

I really enjoy Artem's writing style, and this time, he put together a great guide on setting up ShazamKit, detecting songs, and managing a library of identified tracks. If you are working with music recognition, this resource could be incredibly valuable!

🥋 An Ode to Swift Enums: The View Models That Could

Swift Enums are an essential tool in every iOS developer's toolkit! Actually, they are one of my favorite features in Swift, offering a powerful way to write more expressive and efficient code.

Using a basketball practice planner app as an example, Jordan dives into the versatility of Swift enums, demonstrating how he tackled different scenarios using only this type.

Our current sprint at work includes a significant revamp of our app for iPads. One of the most exciting updates is iOS 18's new TabView, which places the tab bar at the top of the screen with text-only items, while on iPhones, the traditional tab bar remains unchanged.

Beyond the visual updates, Apple has also introduced new functionality — the tab bar can now expand into a sidebar, offering a more structured navigation experience with a detailed hierarchy of items.

SwiftUI Improvements

SwiftUI introduces new capabilities for managing tabs and sidebars more efficiently:

• Simplified syntax: Use TabView with TabViewStyle to create tabs.
• Enhanced roles: Leverage special tab roles, such as .search.

The Plan

This week, I want to explore this new SwiftUI improvement and share insights into how Apple manages tab bars and sidebars with the latest SwiftUI APIs. To demonstrate, I have built a sample app of the newsletter featuring multiple tabs like "Issues", "About" and "Search". When displayed as a sidebar, these tab items become into section headings instead.

<StaticImage src="/issues/issue34/tabars.webp" alt="How the tab bar looks on iPadOS 18." link="https://www.ioscoffeebreak.com/issues/issue34/tabars.webp" caption="How the tab bar looks on iPadOS 18." priority={true} />

Setting Up the TabView

The AppView component is responsible for rendering the tabs. Here you can see how the Search tab differs from the others by using a .search tab role.

enum Tabs: Equatable, Hashable {
    case about
    case issues
    case search
}

struct AppView: View {
    @State private var selectedTab: Tabs = .issues

    var body: some View {
        TabView(selection: $selectedTab) {
            Tab("Issues", systemImage: "book", value: .issues) {
                IssuesView()
            }

            Tab("About", systemImage: "person", value: .about) {
                AboutView()
            }

            Tab(value: .search, role: .search) {
                SearchArticlesView()
            }
        }
    }
}

Enabling Sidebar Toggling

To allow users to switch our tab bar into a sidebar, we need to apply the tabViewStyle view modifier to the TabView as follows:

var body: some View {
    TabView(selection: $selectedTab) {
      // tabs and sections...
    }
    .tabViewStyle(.sidebarAdaptable)
}

Here is the final result:

<StaticImage src="/issues/issue34/ioscoffeebreak_tabbar_sidebar_swiftui.gif" alt="iOS Coffee Break Newsletter SwiftUI sample app." link="https://www.ioscoffeebreak.com/issues/issue34/ioscoffeebreak_tabbar_sidebar_swiftui.gif" caption="iOS Coffee Break Newsletter sample app with iOS 18 new tabviews" />

To explore the full implementation of the sample application, visit the repository on GitHub.

Next week, I plan to migrate this week's sample app to UIKit, leveraging built-in APIs like UITab and UISearchTab. Stay tuned for the update!

<Banner text="CURATED FROM THE COMMUNITY" />

🏠 How much architecture do you really need?

How much architecture does a SwiftUI app really need? Should we strictly follow established patterns, or is a more flexible approach better?

Recently, the debate around SwiftUI and MVVM has resurfaced, and this week, Donny shares his perspective on the topic. And what about you, do you still rely on MVVM, or have you adopted a different architectural style that works best for your projects?

🔬 Debugging An Undebuggable App

Recently, a friend from work shared with me this article by Bryce where he debugs a regular old widget app and I immediately knew that I wanted to feature it in the newsletter.

While debugging and reverse engineering aren't topics I typically cover, I highly recommend following Bryce's work if you are interested in diving deeper into these areas.

🔐 Open/Closed Principle (OCP) in Swift using Decorator Pattern

Have you heard about the Open/Closed Principle (OCP)? If not, this principle encourages building systems where new functionality can be added without altering existing code.

In this article, Arifin breaks down the Open/Closed Principle and shows how to apply it in Swift. Using practical examples, he highlights the power of the Decorator Pattern to extend behavior while keeping the original code untouched.

At a previous sprint at work, I had faced a quite interesting challenge where I had to create an animated transition when selecting items from a grid. The goal was to smoothly move the selected item within the grid.

Initially, I experimented with various withAnimation options but couldn't achieve the desired effect ... until I tried out using SwiftUI's matchedGeometryEffect() modifier 🎉!

Overview

This week, I chose to highlight the matchedGeometryEffect() modifier because it is a great tool for creating smooth, custom transitions between views — perfect even if you are not confident with animations!

Using unique identifiers, you can blend the geometry of two views with the same identifier creating an animated transition. Transitions like this can be useful for navigation or changing the state of UI elements for example.

Steps to enable the Matched Geometry Effect:

• Assign a unique identifier to each view involved in the transition.
• Declare a namespace using the @Namespace property wrapper to group view identifiers.
• Apply the .matchedGeometryEffect(id:in:properties:anchor:isSource:) modifier to the views participating in the animation.

Once set up, when the animation is triggered, views with the same identifier within the same namespace will seamlessly transition between their states.

My Coffees App

I have assembled a practical example to demonstrate the advantages of using this view modifier. Let's imagine you have an app that displays a grid of different types of coffee ☕ and you want to choose your favorites from that list - moving the selected ones from the one grid to the other with a smooth animation!

Here is a preview of what I am aiming for:

<StaticHalfWidthImage src="/issues/issue33/coffees_animation.gif" alt="Coffee selection animation with the matchedGeometryEffect modifier." link="/issues/issue33/coffees_animation.gif" caption="Coffee selection animation with the matchedGeometryEffect modifier." priority={true} />

Here is the code:

struct MyCoffeesView: View {
    [...]

    @Namespace private var namespace
    private let coffeesNamespace = "coffeesNamespace"

    var body: some View {
        ScrollView {
            VStack {
                HeaderView(title: "Favorites")

                LazyVGrid(columns: columns) {
                    if favoriteCoffees.isEmpty {
                        CoffeePlaceholderView()
                    } else {
                        ForEach(favoriteCoffees) { coffee in
                            CoffeeView(coffee: coffee)
                                .matchedGeometryEffect(
                                    id: "\(coffee.name)_\(coffeesNamespace)", in: namespace
                                )
                                .onTapGesture {
                                    withAnimation(.easeIn) {
                                        favoriteCoffees.removeAll { $0.id == coffee.id }
                                    }
                                }
                        }
                    }
                }

                HeaderView(title: "Suggested")

                LazyVGrid(columns: columns) {
                    if filteredSuggestedCoffees.isEmpty {
                        CoffeePlaceholderView()
                    } else {
                        ForEach(filteredSuggestedCoffees) { coffee in
                            CoffeeView(coffee: coffee)
                                .matchedGeometryEffect(
                                    id: "\(coffee.name)_\(coffeesNamespace)", in: namespace
                                )
                                .onTapGesture {
                                    withAnimation(.easeIn) {
                                        favoriteCoffees.append(coffee)
                                    }
                                }
                        }
                    }
                }
            }
            .padding(.all)
        }
        .navigationBarTitle("My Coffees", displayMode: .inline)
    }
}

To explore the full implementation of the sample application, visit the repository on GitHub.

<Banner text="CURATED FROM THE COMMUNITY" />

🌳 Let's Build: The tree Program - Part I

SwiftToolkit is launching a new series called Let's Build!

In the first article of the series, you will explore file system traversal while building a directory listing tool. This guide will walk you through using PathKit and the Swift Argument Parser to efficiently navigate and display directory structures.

⛔️ Task Cancellation in Swift Concurrency

In most cases, Swift Concurrency automatically manages task cancellation, but there are situations where manual handling is necessary.

Majid's latest article explores Swift's cooperative cancellation model, explaining how developers can take control of task cancellation and decide when and how to stop execution!

👷🏻‍♂️ Presenting and Managing Expandable Sections in SwiftUI

Expanding and collapsing views is essential for improving user experience. This is particularly useful when deciding which information to display in limited space.

SerialCoder's latest article covers how to manage the expanded state programmatically and how to let users expand and collapse sections on demand - all done in SwiftUI!

Who doesn't love code reviews, right? 😅 Recently, I watched Daniela Vrzan's talk, Best-in-class Pull Request from NSSpain 2024, and it gave me the inspiration for this week's issue. I will be sharing some valuable tips to help you improve the way you create Pull Requests and make the review process smoother and more effective.

What is a Pull Request? 🤔

A pull request is a way to propose merging a set of changes from one branch into another. It enables team members to review, discuss and provide feedback before the updates are incorporated into the main codebase.

Tips to Write better PRs:

• Don't do big PRs
• Concise (write good descriptions)
• Visual (screenshots/video)
• Understandable and well-documented
• Review your own pull request first
• Avoid nitpicking!

Why and How to Add a PR Template?

By having consistent prompts pre-filled in your description, you will always have a clear structure to follow, ensuring that your reviewers receive all the necessary details efficiently.

• Create a .github directory at the root of your repository
• Inside it, add a file named pull_request_template.md
• Use GitHub's Markdown syntax to include prompts or guidelines that can help contributors provide useful information

From now on, whenever you create a PR, the description field will automatically include your template content! Great Job! 💪

What Should Your Template Include?

You can add any prompts that suit your workflow. Personally, I like to keep it straightforward. Here is an example of a template:

# Problem Overview
- Brief description on what this PR is about
- Attach screenshots or anything valuable to the reviewer to give them context about your PR

# How To Test
- Step 1 
- Step 2 
- Step 3 

# Before And After
|            Before           |               After            |
|             :---:           |               :---:            |    
|       <screenshot here>     |        <screenshot here>       |

# Problem Solution
- Describe key changes 

## Issue
- [Jira task](<link>)

## How does this PR make you feel? (optional)
- [Gif](<link>)

Hopefully, these simple tips will help you turn each pull request into something special, making the review process more efficient and enjoyable for both you and your team 🤘!

<Banner text="CURATED FROM THE COMMUNITY" />

🗺️ Drawing maps with Swift Charts

Artem got inspired by a Swift Charts WWDC session and decided to create an application to visualize population data of Kazakhstan 🇰🇿, the country where he resides.

If you are interested in learning how to create maps using Swift Charts, this article is definitely worth a read!

✌️ Custom Fastlane Actions

While Fastlane offers many built-in actions, there are times when you need a custom solution tailored to your workflow.

In his latest article, Noam explains how to create custom Fastlane actions and also dives into unit testing your Fastlane code!

✂️ Swift 5.9: Copyable Syntax

What exactly is a Copyable?

In her latest article, Vera explores the concept of noncopyable structs and enums, a topic that has been gaining traction recently. This new Swift 5.9 feature improves code safety by preventing unintended copying of certain types.

If you are curious to learn more, Vera has put together a clear and insightful article where she shares her findings!

🦑 Mastering TaskGroups in Swift

Swift Structured Concurrency simplifies handling multiple asynchronous tasks with task group. These allow you to run a dynamic number of child tasks, wait for all to complete or cancel them if needed.

Majid's latest article dives into how to effectively use and optimize task groups in Swift. It includes several practical code examples to illustrate their implementation, making it a great resource for improving your concurrency skills!

When I first started posting on Twitter, I wasn't happy with how my newsletter posts displayed, so I built an automated system using SwiftUI and GitHub Actions to generate dynamic preview images for my weekly issues. This approach saves time and ensures each post has a unique, professional look when shared online.

This automated system is out the scope of this week's issue, but if you are curious on how I did it, I recommend checking out the article I wrote on this topic. It walks you through the entire process step by step!

This week, I am diving into the key class that made it all possible 🎉 — ImageRenderer. I will show you how it works and how you can easily integrate it into your apps!

Overview

ImageRenderer is a straightforward tool that can convert a SwiftUI view into various image formats such as CGImage, NSImage or UIImage.

Using it is easy — just create an instance, give it some content and request an image output.

let renderer = ImageRenderer(content: view)
self.image = renderer.uiImage

To see how the renderer works in a working example, here I am creating an image preview for my weekly issues given some properties such as the issue title and number.

@main
struct IssuePreview: AsyncParsableCommand {
    [...]

    @MainActor mutating func run() async throws {
        [...]

        let view = IssueView(
            colors: colors,
            foregroundColor: foreground,
            title: issue.title,
            date: date,
            issueNumber: issue.number
        )
        .frame(width: 1280, height: 640)

        guard let image = ImageRenderer(content: view).nsImage else { throw Error.invalidImageData }
        guard let imageData = image.asPNGData else { throw Error.imageCreationFailed }

        let folderURL = URL(fileURLWithPath: "issues")
        let fileURL = folderURL.appendingPathComponent("\(issue.number).png")
        try imageData.write(to: fileURL)
    }
}

The Output

Although I am (still considering) to make some adjustments and improvements, here is what I have got so far:

<StaticHalfWidthImage src="https://raw.githubusercontent.com/henriquestiagoo/ioscoffeebreak-ci/main/issues/15.png" alt="iOS Coffee Break Newsletter issue #15 with custom image preview!" link="https://x.com/twannl/status/1669629139609944064" caption="iOS Coffee Break Newsletter issue #15 with custom preview image!" />

<Banner text="CURATED FROM THE COMMUNITY" />

🍎📱💻 Multiplatform Development for Apple Devices

Are you working to make your app run across multiple Apple platforms?

In his first blog post of 2025, Darryl walks through the process of bringing his side project to the Vision Pro. If you are working on making your own apps compatible with new Apple devices, this is definitely worth a read!

🦺 Container relative frames in SwiftUI

If you have encountered performance issues from overusing GeometryReader in your SwiftUI apps, you might want to check out Majid's article!

He explains how to use the containerRelativeFrame view modifier, which allows you to define a view’s size relative to its parent without relying on GeometryReader. This can help simplify your layouts and improve performance.

🎙️ Dev Conversations #6: Krzysztof Zabłocki

Dev Conversations is a monthly series where Swift Toolkit features people who contribute to the Swift community!

In episode #6, Natan interviews Krzysztof, the creator of Sourcery, to discuss his career, open-source contributions, and his decision to leave a full-time job to become independent. It is a great talk that might just inspire you to go full indie 🚀!

In last week issue and part 2 of the series on App Intents, I showed you how to take advantage of App Intents and take the to-dos working sample app to the next level by using the ShowsSnippetView protocol to return a custom view as a result of performing an action.

In case you missed the previous issues, you can check out part 1 here and part 2 here.

Tired of App Intents already? We are not over yet 😅 ...

This week, we reach the 3rd and final part of the series on App Intents! This time, I will continue refining my to-dos sample app and show you how you can create interactive widgets 🕹 using App Intents.

The Plan

• Create a widget that displays the top three to-do items.
• Enable users to mark a to-do as completed directly from the widget.

I have written a detailed guide on the topic here. If you are interested in diving deeper into the implementation details,I highly recommend giving it a read!

Here is the final result:

<StaticHalfWidthImage src="/issues/issue30/mark_todo_completed_widget.gif" alt="Marking a to-do as completed using the widget." link="https://www.ioscoffeebreak.com/issues/issue30/mark_todo_completed_widget.gif" caption="Marking a to-do as completed using the widget." priority={true} />

To explore the full implementation of the sample application, visit the My To-dos app repository on GitHub.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

<Banner text="CURATED FROM THE COMMUNITY" />

🥸 Generating Analytics Code with Mustache

Ever wondered how to build a CLI tool that generates code?

This week, Swift Toolkit shared an detailed guide on generating analytics events from markdown tables using Mustache templates, transforming them into Swift or Kotlin code.

🏆 How to Build a Dream Team: A Guide to Recruiting Great Mobile Developers

Finding and recruiting exceptional developers who align with your culture is hard! Pawel has put together a valuable guide sharing his insights on what truly counts when assembling high-performing iOS development teams.

If you are currently applying for new positions or even if your team is hiring, this article might be of great value for you.

🧩 Creating a reusable action menu component in SwiftUI

At some point in your development journey, I bet you've likely encountered code that feels repetitive, overly dependent on the app's data model, and lacking in structure.

In his latest article, Peter walks you through the process of building a reusable SwiftUI component, helping you write cleaner and more maintainable code!

📜 Swift 1:1: Protocols

Regardless of the programming language — be it Swift, Kotlin, or C# — protocols (or interfaces) provide an effective way to handle data flow between objects.

In her latest article, Vera breaks down Swift protocols in an easy-to-understand manner, making it accessible for developers at all levels.

🤖 Running SwiftFormat on CI

If you or your team run workflows on any CI platform, you know that getting them to work in that environment is a different story from running them locally!

Noam has written an insightful guide on how to create a script that runs SwiftFormat, detects any file changes, and commits them automatically — all set up to work seamlessly within your CI pipeline.

Last week issue discussed the advantages and implementation details of the App Intents and the App Shortcuts frameworks in iOS, using a to-dos sample application as a working example.

In case you missed the previous issue, you can check it out here.

Do you recall the boring dialog that gets displayed when our todo is marked as completed? What if there is a way to improve it 🤔 ...

<StaticHalfWidthImage src="/issues/issue29/mark_resolved_intent_with_dialog.gif" alt="My To-Do App Intents demo with Dialog." link="https://www.ioscoffeebreak.com/issues/issue29/mark_resolved_intent_with_dialog.gif" caption="My To-Do App Intents demo with Dialog." priority={true} />

This week, I will show how you can take App Intents to the next level by taking advantage of the ShowsSnippetView protocol to return a custom view as a result of performing an action.

Jumping to the Code

First, lets create our view. Here is how the custom TodoActionView looks:

import SwiftUI

struct TodoActionView: View {
    let action: TodoAction
    let title: String

    var body: some View {
        HStack {
            Image(systemName: action.imageName)
                .imageScale(.large)
                .font(.largeTitle)
            Text("'\(title)' \(action.name).")
                .font(.title2)
        }
        .padding()
    }
}

To display a view when marking a to-do as completed, update the perform method's return type to include ShowsSnippetView. Then, use the result method to pass TodoActionView as a parameter.

Here is how the code looks:

import AppIntents
import SwiftUI

struct MarkTodoAsCompletedIntent: AppIntent {
    [...]

    func perform() async throws -> some ShowsSnippetView {
        let suggestedEntities = try await suggestedEntities()
        if suggestedEntities.isEmpty {
            return await .result(view: TodosEmptyView())
        } else {
            let entityToUpdate = try await $titleEntity.requestDisambiguation(
                among: suggestedEntities,
                dialog: IntentDialog("Select the todo you wish to mark as completed:")
            )
            // mark todo as completed
            try await markAsCompleted(title: entityToUpdate.id)
            return .result(view: TodoActionView(action: .markAsComplete, title: entityToUpdate.id))
        }
    }

    [...]
}

With that simple adjustment, the App Intent action delivers a custom and more engaging view. Here is how the demo of the sample to-dos application now behaves:

<StaticHalfWidthImage src="/issues/issue29/mark_resolved_intent_with_view.gif" alt="My To-Do App Intents demo with custom view." link="https://www.ioscoffeebreak.com/issues/issue29/mark_resolved_intent_with_view.gif" caption="My To-Do App Intents demo with custom view." priority={true} />

For those interested in diving deeper into this topic, consider experimenting with various types of intents to see how they can be customized to meet your app's specific needs.

If you are considering adding App Intents to your app, make sure to review the Human Interface Guidelines. They provide valuable insights into what types of actions are suitable for App Intents, ensuring they align with best practices and offer an intuitive user experience.

I am planning to release a 3rd part of my App Intents issues by powering up my to-do sample application with interactive widgets! Stay tunned!

To explore the full implementation of the sample application, visit the to-dos app repository on GitHub.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

<Banner text="CURATED FROM THE COMMUNITY" />

🤘 Favorite Xcode shortcuts

Xcode offers countless shortcuts, and I am sure everyone has their go-to favorites. In his latest article, Nowham highlights the most useful shortcuts he relies on daily. It is a must-read for improving efficiency!

If you are like me and keep mistyping variables names all the time, the Edit all in scope shortcut comes pretty handy!

🔨 Swift Argument Parser with Guilherme Rambo

Swift Toolkit has released an insightful video featuring Natan and Gui Rambo, where they delve into Command Line tools in Swift. They showcase a practical refactor and demonstrate integrating CLI functionality into macOS apps.

If you are passionate about tooling and server side in Swift, Swift Toolkit is the right place for you.

🧑‍💻 Attending Apple Intelligence and App Intents workshop

While researching for my latest issue, I came across Dean's blog and his insightful article on Apple Intents. Dean recently attended an Apple Intelligence and App Intents workshop in Paris, led by an Apple expert, and shared his experience in detail.

It is exciting to see Apple hosting such local events worldwide. I would be thrilled to have the chance to participate in one someday!

✂️ Introduction to Non-Copyable types in Swift

Have you come across non-copyable types in Swift? I hadn't until recently!

This new feature, recently introduced to Swift, enhances code safety by preventing unintended copying of certain types. If you are curious to learn more, Vincent has created a straightforward video explaining the concept and its practical applications.

This week I wrote an article that discusses the advantages and implementation details of the App Intents and the App Shortcuts frameworks in iOS, using a To-dos sample application as a working example to demonstrate how they can make user interactions easier and more intuitive.

The App Intents framework enables seamless integration of your app's features with system experiences like Siri, Spotlight and Shortcuts. Enhanced by Apple Intelligence, it boosts discoverability and personalization by suggesting actions and enabling interactions across apps.

For this example, we are interested in the following actions:

• Show the list of tasks
• Add a new task
• Remove a task
• Mark a task as completed

Defining App Intents

To define App Intents, just add a new file to your main app target and create a struct that conforms to the AppIntent protocol. The system will automatically discover any intents defined by your app and will show them accordingly where appropriate.

We will take as example the add to-do intent that looks as follows:

import AppIntents

/// Add to-do App Intent
struct AddTodoIntent: AppIntent {
    static var title: LocalizedStringResource = LocalizedStringResource(stringLiteral: "Add item to todos list")
    static var description: IntentDescription? = IntentDescription(stringLiteral: "Add an item to todos list")

    @Parameter(title: "Todo title")
    var todoTitle: String?

    func perform() async throws -> some ProvidesDialog {
        guard let todoTitle else {
            let dialog = IntentDialog("What todo item you would like to add?")
            throw $todoTitle.needsValueError(dialog)
        }

        let newTodo = Todo(title: todoTitle)
        do {
            try await insert(todo: newTodo)
            let dialog = IntentDialog("'\(todoTitle)' was added to your todos list.")
            return .result(dialog: dialog)
        } catch {
            throw error
        }
    }

    @MainActor
    func insert(todo: Todo) async throws {
        let todosManager = TodosManager(context: MyTodosApp.container.mainContext)
        try await todosManager.insert(todo: todo)
    }
}

Making your Intents accessible through Shortcuts

A great feature of Intents is their ability to appear in multiple system locations. To ensure actions are accessible via Spotlight, you need to implement an AppShortcutsProvider instance.

import AppIntents

struct MyTodosShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: AddTodoIntent(),
            phrases: [
                "Add an item to \(.applicationName)",
                "Add item to \(.applicationName)",
            ],
            shortTitle: LocalizedStringResource(stringLiteral: "Add an item to todos list"),
            systemImageName: "plus.circle.fill"
        )
    }
}

With this setup, your app's functionality becomes fully accessible as a Shortcut.

Here is a demo of the sample to-dos application using App Intents.

<StaticHalfWidthImage src="/issues/issue28/addtodo.gif" alt="My To-Do App Intents demo." link="https://www.ioscoffeebreak.com/issues/issue28/addtodo.gif" caption="My To-Do App Intents demo." priority={true} />

App Intents can also power interactive widgets, controls and live activities, which I plan to explore in future issues!

To explore the full implementation of the sample application and to get more details of how App Intents and App Shortcuts frameworks work, visit my latest article on my blog.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

<Banner text="CURATED FROM THE COMMUNITY" />

🪚 Creating tiny utility apps with SwiftUI Previews

In this post, Daniel demonstrates how to create lightweight apps without needing to install them on a device by leveraging SwiftUI Previews and Swift Package internal views. Thanks to SwiftUI, which simplifies development compared to UIKit and AppKit, you can build cross-platform apps efficiently.

Personally, I believe this method serves as an excellent alternative to standalone apps, streamlining the development process and saving time to focus on other priorities 👌.

🪥 How a new Xcode 16 feature helped my work project eliminate 66,000 lines of code

Xcode 16's new buildable folders don't depend on .pbxproj for recognising files, which helps teams avoid possible merge conflicts with file changes in their git branches. This feature allowed Makwan's team to find over 100 unused Swift files and eliminate a total of 66,000 lines of code.

I suggest reading this article for a deeper understanding of how the author and the team tackled this time-consumig process. It might inspire you to clean up some of your project's files as well!

🪝 Swift 6: Typed Throws

Swift 6 introduces many exciting features, including Typed Throws, which improve the way we handle errors.

In her latest blog post, Vera explains how specifying error types allows the compiler to detect issues more appropriately.

🖊️ The ultimate guide to signing CLIs for macOS (Darwin)

Did you ever get the error "'your-cli' can't be opened because Apple cannot check it for malicious software." after installing a macOS CLI tool? I bet you did - this happens because macOS has a security feature called Gatekeeper, which is designed to ensure that only trusted software runs on the system.

Pedro from Tuist has written a comprehensive guide on signing and notarizing your CLI tool for macOS to resolve this issue effectively!

As the year comes to an end, what a journey it has been! I am incredibly proud of everything I have created in 2024!

I had two big concerns when I started the newsletter: not to be able to find or receive from the community enough iOS content to feature every month and not to have enough people interested in subscribing. Those worries are now behind me! I now receive plenty of requests to showcase new articles and have transitioned to releasing issues weekly. On top of that, we are close to 500 subscribers!

I am incredibly grateful to everyone who has supported the newsletter, whether by subscribing or contributing with such amazing content. Thank you all 🙏!

Here is a quick look back at some highlights from your favorite iOS newsletter ☕.

Year Highlights

2024 was a big year for the newsletter:

• Launch of iOS Coffee Break in May 2024.
• 7.6k unique visitors to the site.
• 27 issues published.
• Revamp of the site, including a dedicated page to sponsorship opportunities.

Take a deeper dive with me into the most popular issues from the past year.

Top Issues

🧰 The collection of open-source iOS tools I rely on daily ✌️

This was one of my favorite issues to write, and it turned out to be the most read in the newsletter! I showcased some open-source tools that I frequently use in both professional and personal iOS development.

👷 Refactoring my SwiftUI Navigation Layer to follow the Coordinator Pattern 🔀

The second most popular issue in the newsletter focused on refactoring my earlier SwiftUI Navigation Layer. Here, I transitioned from a Router to a Coordinator model and the main goal of this refactoring was to transition from a linear navigation stack to a distinct set of independent navigation screens using sheet presentations.

I must say, this was the issue I dedicated the most time and effort to 😅!

🧑‍✈️ GitHub Copilot for Xcode is now available! ✈️

Rounding out the top three of my most viewed issues is the announcement of GitHub Copilot for Xcode!

With AI being such a hot topic in 2024, it is no surprise this issue resonated with readers. This Xcode extension offers inline code suggestions as you type, significantly boosting development efficiency.

See you in 2025! 🥳

I am deeply grateful to all my readers and subscribers for their unwavering support. Your engagement inspires me to continue creating free, valuable content for the iOS community. I couldn't do it without you — thank you 🙏

I wish you lots of coffees and I hope to see you in 2025 🥳

It is that time of year again — Merry Christmas, everyone 🎄🎅 Wishing you a joyful holiday season filled with rest, relaxation, cherished moments with your loved ones!

One of the standout announcements at WWDC 2024 was the introduction of the Image Playground framework, a powerful image generator powered by an on-device diffusion model. This innovative tool offers advanced capabilities directly on Apple devices. The API for Image Playground is currently in beta and is compatible with iOS 18.2, iPadOS 18.2, and macOS 15.2 or later.

To use the Image Playground app, ensure Apple Intelligence is enabled by navigating to System Settings > Apple Intelligence & Siri. In my case, I had to adjust the Apple Intelligence language to English (US) to match my system language. Only then did the option to toggle on Apple Intelligence become available.

Integration in a SwiftUI App

The method imagePlaygroundSheet(isPresented:concept:sourceImageURL:onCompletion:onCancellation:) allows the presentation of the sheet where the user generates images from the specified inputs. In SwiftUI, you present this interface as a sheet from one of your views:

import ImagePlayground
import SwiftUI

struct ImagePlaygroundView: View {
    @State private var isImagePlaygroundPresented = false
    @State private var imageURL: URL?
    @Environment(\.supportsImagePlayground) private var supportsImagePlayground

    var body: some View {
        VStack {
            if let imageURL {
                AsyncImage(url: imageURL) { image in
                    image
                        .resizable()
                        .scaledToFit()
                        .frame(maxHeight: 300)
                } placeholder: {
                    ProgressView()
                }
            }

            if supportsImagePlayground {
                Button("Generate", systemImage: "wand.and.sparkles") {
                    isImagePlaygroundPresented.toggle()
                }
            } else {
                Text("Image Playground is not supported on this device.")
                    .multilineTextAlignment(.center)
            }
        }
        .padding()
        .imagePlaygroundSheet(
            isPresented: $isImagePlaygroundPresented,
            concepts: [.text("cat"), .text("astronaut")]
        ) { url in
            imageURL = url
        }
    }
}

I was not able to run this code on an iOS simulator with Apple Intelligence enabled. If you have managed to make it work, please let me know on Twitter!.

Here is the result of the sample code running on my mac:

<StaticImage src="/issues/issue26/image_playground_output.webp" alt="Custom Optional output." link="https://www.ioscoffeebreak.com/issues/issue26/image_playground_output.webp" caption="Output image from the sample code." priority={true} />

Apple's Image Playground allows developers to create visually engaging experiences while ensuring smooth integration with app frameworks. Currently, the model just supports generating animations and illustrations, but my expectation is that future updates will expand its capabilities!

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

☠️ NSSpain XII (2024) talks are available online!

NSSpain was one of the iOS conferences I eagerly anticipated attending this year, but unfortunately, I couldn't make it.

Thankfully, for those who missed out, the NSSpain team has generously uploaded all the talks from the 12th edition to Vimeo, making them accessible to everyone. Consider it as a christmas gift! 🎄🎅

👀 Now Previewing Navigator!

I have been a long-time follower of Michael's work and greatly admire his approach to Dependency Injection using the Factory and Resolver libraries. I even integrated Factory into Padel Time, my side project built entirely in SwiftUI, and it definitely made my life easier!

Michael's latest project, Navigator, offers a streamlined yet robust navigation layer built around NavigationStack. As it is still in its pre-release phase, this is an excellent opportunity to dive in, experiment, and provide feedback to shape its development!

🧩 Xcode Kotlin - Xcode support for Kotlin browsing and debugging

At work, we use a KMP module written in Kotlin that is shared between our iOS and android apps. A recurring issue for the iOS team has been debugging the Kotlin code when unexpected behavior occurs. So far, we have had to rely on less effective approaches like using print statements to identify problems.

Thankfully, Touchlab's new xcode-kotlin plugin directly integrates Kotlin debugging into Xcode. This tool simplifies troubleshooting shared code, and it is something I am excited to introduce to my team for improved efficiency!

🥸 Templating with Mustache: an Interactive Tutorial

When I discovered this post, I knew it had to be in this week's newsletter. A few years ago, I worked on a tvOS project at work where we used a templating engine with Mustache.js to design TVML pages. The engine injected data into templates at runtime to generate dynamic content for tvOS.

Natan's latest article in Swift Toolkit explores leveraging Mustache in Swift to create code, HTML, and dynamic content. His guide offers a clear deep dive into its practical applications and it is definitely a great skill to have!

🚀 Swift Package Scripts 0.2 is out!

Daniel Saidi has launched version 0.2 of Swift Package Scripts! This repository includes helpful shell scripts for tasks like building, testing, generating Docc documentation, and creating new versions.

With v0.2, you can specify platforms for execution, and it introduces a multi-platform compatible XCFramework script. I will definitely apply some of these scripts into my workflows!

🕵️‍♂️ The Ultimate Guide to Validation Patterns in SwiftUI

Validation plays a crucial role in crafting reliable and user-friendly applications, and it doesn't need to be overly complex!

Azam has written a detailed guide showcasing techniques for implementing effective validation in SwiftUI apps, emphasizing strategies to improve both data integrity and the overall user experience.

The iOS community has a very active open-source scene, which provides a lot of useful tools to improve the quality of an app. This week, I am highlighting some open-source utilities that I regularly use in both my professional and personal iOS development projects.

SwiftLint

SwiftLint enforces coding standards and best practices in Swift, promoting clean, maintainable, and readable code. It flags issues like force-unwrapping through warnings and errors, similar to a code review. By automating this process, SwiftLint reduces manual effort during reviews, enabling developers to focus on more critical aspects.

Here is an example of how you can disable rules in code:

// swiftlint:disable colon
let noWarning :String = "" // No warning about colons immediately after variable names!
// swiftlint:enable colon
let hasWarning :String = "" // Warning generated about colons immediately after variable names.

If you are not aware, you can install and run SwiftLint globally, allowing you to check the code quality of any file on your Mac.

Fastlane

Fastlane is a versatile automation tool designed for mobile app projects, offering a wide array of actions and plugins. It allows you to create complex workflows, known as "lanes" to perform tasks such as building, testing or deploying your iOS application. It integrates seamlessly with various CI services and uses a configuration file called a Fastfile to define these workflows. This makes it a powerful solution for streamlining repetitive processes and maintaining efficiency in your app development pipeline.

Here is a sample Fastfile with a test lane:

default_platform(:ios)

platform :ios do
  project_path = "myProject/myProject.xcodeproj"

  desc "Run iOS tests"
  lane :test do
    run_tests(
      project: project_path
    )
  end
end

SwiftGen

SwiftGen is a tool that generates Swift code to provide type-safe access to project resources like images, localized strings, and more. By automating this process, SwiftGen helps prevent runtime errors caused by incorrect resource usage, ensuring a safer and more efficient development workflow.

Here is an usage example:

// You can create new images by referring to the enum instance and calling `.image` on it:
let bananaImage = Asset.Exotic.banana.image
let privateImage = Asset.private.image

// You can create colors by referring to the enum instance and calling `.color` on it:
let primaryColor = Asset.Styles.Vengo.primary.color
let tintColor = Asset.Styles.Vengo.tint.color

// You can create data items by referring to the enum instance and calling `.data` on it:
let data = Asset.data.data
let readme = Asset.readme.data

Sourcery

Created by Krzysztof, Sourcery is a Swift code generator built on top of SwiftSyntax. It enhances language abstractions, enabling developers to automatically create boilerplate code.

Here is an example of how to use it with a Struct:

struct Article: Hashable, Identifiable, Equatable, Codable {
    // sourcery: customMock = "0"
    let id: Int
    let title: String
    let url: String
}

You can use Sourcery Annotations to write the default value for the generated mock.

Here is the code generated by Sourcery:

// MARK: - Generated Article
extension Article {
    static func mock(
        id: Int = 0,
        title: String = "",
        url: String = ""
    ) -> Article {
        .init(
            id: id,
            title: title,
            url: url
        )
    }
}

What would you add to this list? Let me know on Twitter!

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

📬 Deploying an Email System with SwiftCloud

Recently, Natan from Swift Toolkit.dev introduced a feature on his website allowing readers to subscribe to email updates for new posts. This week, he partnered with Andrew to create a hands-on video using SwiftCloud, showcasing a quick recap of his mailing system built entirely in Swif.

If you are considering adding a Swift-based mailing system to your newsletter, this resource is definitely worth exploring!

🤖 Creating ML models with Create ML

Artem recently concluded his series on text analysis with a post detailing how to create a custom machine learning model for sentiment analysis in new languages using Apple's Create ML tool.

Though I hadn’t tried Create ML before, this article highlighted how straightforward it is to use without requiring extensive machine learning expertise. With a strong dataset, it serves as an excellent starting point for building machine learning models for your apps!

❌ Bad practice: not using the modern formatting API

DateFormatter is incredibly handy but can be prone to errors! Mistakes like using an incorrect format or creating too many instances can harm performance.

Since iOS 15, Apple introduced a cleaner, more efficient API for formatting values. In this brief post, Vincent provides an excellent introduction to this modern approach, showing how you can start leveraging it to simplify and optimize your apps.

Swift's Optional type ensures safer code by clearly managing values that may or may not exist! While Swift natively supports Optionals with (?), some libraries or frameworks lack this syntax.

A common iOS interview question is: How can you create a custom Optional?

Here is a quick implementation:

// MARK: - Optional is an enum with two cases: some value and none (nil)
enum CustomOptional<T> {
    case some(T)
    case none

    var value: T? {
        switch self {
        case .some(let value):
            return value
        case .none:
            return nil
        }
    }

    func unwrapped() throws -> T {
        switch self {
        case .some(let value):
            return value
        case .none:
            throw CustomOptionalError.valueIsNil
        }
    }

    // MARK: - Custom Optional Error enum
    enum CustomOptionalError: Error {
        case valueIsNil
    }
}

// MARK: - Initializing the value
let customOptionalString: CustomOptional<String> = .some("hello world!")
do {
    let value = try customOptionalString.unwrapped()
    print("Custom optional string value unwrapped: \(value)")
} catch {
    print(error)
}

let customOptionalIntNoValue: CustomOptional<Int> = .none
do {
    let value = try customOptionalIntNoValue.unwrapped()
    print("Custom optional int value unwrapped: \(value)")
} catch {
    print(error)
}

Here is the console output:

<StaticImage src="/issues/issue24/custom_optional_output.webp" alt="Custom Optional output." link="https://www.ioscoffeebreak.com/issues/issue24/custom_optional_output.webp" caption="Custom Optional output." priority={true} />

Mastering optionals is key to writing reliable Swift code. Creating custom optional types helps understand their structure and allows extension for specific needs. Whether preparing for interviews or deepening knowledge of Swift, becoming proficient in optionals strengthens your skills as an iOS developer 💪!

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

👅 Working with Natural Language framework

Part 2 of Artem's SwiftUI text editing series dives into the Natural Language framework, showcasing its real time text analysis capabilities.

I am surprised this framework isn't used more often. It is a powerful tool for text analysis — free, fast, and fully functional offline!

🧰 Mastering Swift for Scripting & Tooling

Natan's Swift Connection 2024 talk is now available, and it is one I have been eagerly anticipating! I have been following Natan's work for a while, and I am a big fan of his clear, engaging teaching style!

If you are interested in scripting, tooling, or deepening your Swift expertise, this is a must-watch talk!

🤦‍♂️ Static, Dynamic, Mergeable, oh, my!

How do static and dynamic linking impact build times?

If this concept feels unclear, I recommend checking out Jacob's insightful explanation to clarify the differences and their effects on your builds! It is definitely worth a read!

✌️ Storing two types in the same variable using Either

Vincent shared a clever tutorial on refactoring code to handle mixed data types using a generic Either enum. This enum supports two generic types, with each case storing an associated value of one type. It is a versatile approach, similar to Swift's Result type.

Is it just me, or are enums amazing?

If you have been following recent issues, I built a navigation layer for SwiftUI apps. While testing my sample app in different Xcode simulators, I noticed it didn't look great on iPads or macOS!

This week, I decided to build on top of my previus work to demonstrate how simple it is to support multiple platforms with SwiftUI. For that, I tried out NavigationSplitView, a view I hadn't used before, and discovered how seamlessly it integrates with existing code, making it both intuitive and effective to implement.

This class is particularly useful for implementing sidebar support on iPads running versions earlier than iOS 18. However, for apps targeting iOS 18 or later, the new Sidebars feature is the recommended approach.

NavigationSplitView is a SwiftUI component designed to create a sidebar-detail layout, where the sidebar controls the content displayed in the detail view. This structure is ideal for apps that organize data into collections and require a detailed view for individual items, making it especially useful for iPad or macOS applications. Using this type is quite simple and intuitive.

// For two-column navigation
struct AppView: View {
    var body: some View {
        NavigationSplitView {
            // sidebar
        } detail: {
            // item details
        }
    }
}

// For three-column navigation
struct AppView: View {
    var body: some View {
        NavigationSplitView {
            // sidebar
        } content: {
            // content list
        } detail: {
            // item details
        }
    }
}

Integrating this new type was simple and seamless. I created a SwiftUI view named SidebarView to display my list of issues, including a binding property to track the currently selected issue.

struct SidebarView: View {
    @Binding var selectedIssue: Issue?

    var body: some View {
        List(
            Issue.sortedMocks,
            selection: $selectedIssue
        ) { issue in
            NavigationLink(value: issue) {
                IssueRowView(issue: issue)
            }
        }
        .navigationTitle("Issues")
    }
}

My root view now incorporates a NavigationSplitView for an adaptive layout across various devices and screen sizes. I also added a @State property to manage the selected issue, which dynamically determines the content displayed in the detail view.

struct AppView: View {
    [...]
    @State private var selectedIssue: Issue?

    var body: some View {
        NavigationSplitView {
            SidebarView(selectedIssue: $selectedIssue)
               
        } detail: {
            if let selectedIssue = selectedIssue {
                IssueView(issue: selectedIssue)
            } else {
                Text("Choose any article to view its details.")
            }
        }
    }
}

If you are only interested in the code, here is the GitHub repository.

With just a few adjustments, I was able to deliver a consistent and user-friendly interface for my sample app across iPhone, iPad and macOS. Here is the final result:

<StaticSmallImage src="/issues/issue23/app_iphone.webp" alt="iOS Coffee Break Sample App running on iPhone." link="https://www.ioscoffeebreak.com/issues/issue23/app_iphone.webp" caption="iOS Coffee Break Sample App running on iPhone." priority={true} />

<StaticImage src="/issues/issue23/app_ipad.webp" alt="iOS Coffee Break Sample App running on iPad." link="https://www.ioscoffeebreak.com/issues/issue23/app_ipad.webp" caption="iOS Coffee Break Sample App running on iPad." priority={true} />

<StaticImage src="/issues/issue23/app_macOS.webp" alt="iOS Coffee Break Sample App running on macOS." link="https://www.ioscoffeebreak.com/issues/issue23/app_macOS.webp" caption="iOS Coffee Break Sample App running on macOS." priority={true} />

For reference, if you want to learn more about NavigationSplitView, you can check out this video from WWDC 2022 or take a look at Food Truck sample code, Apple's sample app on how to build a SwiftUI multiplatform app.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

🤓 Impress at Job Interviews by Inspecting their App Bundle

In his article, Jacob shared a pratical technique for inspecting and analyzing app bundles. By downloading an .ipa file, converting it into a .zip file, and unzipping it, you can explore its contents.

This method can be especially useful for learning or preparing for interviews - just ensure you are ready to address questions on this topic!

🔣 Exploring SF Symbols: Where to Start and How to Use Them (Part 1)

SF Symbols have been around for some time, but with Apple introducing animated SF Symbols at this year's WWDC, Matt wrote a detailed article on the current state of these icons.

Even if you are familiar with how SF Symbols function, this article is a great refresher and might teach you something new!

🤖 Upgrade Your Pull Requests With ChatGPT

Vera shared a valuable tip this week on using AI to enhance Pull Requests. She recommends leveraging ChatGPT to create UML diagrams quickly, saving time and adding clarity to your PRs.

While I hadn't considered including diagrams in my PRs before, this approach seems practical — just make sure the diagrams are accurate and relevant!

🛡️ Private Swift Package Manager: A Better Way to Share Your Code

Ajay shared an insightful article on distributing private Swift Packages efficiently without managing individual repository access or manual framework updates.

His approach consists in a clever use of fine-grained tokens that ensures a seamless experience for users, keeps your code secure, and gives you full control — allowing token revocation or updates anytime.

🤯 New Xcode 16 Feature

Vincent recently highlighted a handy new feature in Xcode 16 that I hadn't noticed before but is sure to streamline your workflow!

You can now paste content directly into the Project Navigator, and Xcode will automatically generate a new file with an appropriate name. One caveat I observed is that imports are missing in the generated file, though hopefully, future updates will address this!

I strongly support a clear separation of concerns for a clean design pattern, and in my experience, separating navigation logic from views is essential for scalability. Recently, I implemented a navigation layer for my SwiftUI apps, initially handling only stacked screen navigation. I left out sheet and full-screen presentations, planning to add them later.

So, this week, I published an article on refactoring my navigation layer to handle additional presentation types, enabling more versatile navigation. I transitioned from a Router to a Coordinator model and the picture below illustrates how I can navigate the app after the update.

<StaticImage src="/issues/issue22/coordinators_diagram.webp" alt="Coordinators Diagram." link="https://www.ioscoffeebreak.com/issues/issue22/coordinators_diagram.webp" caption="Coordinators Diagram." priority={true} />

The main objective was to transition from a linear navigation stack to a distinct set of independent navigation screens using a sheet presentation. Here is a quick demo from the sample project I have set up:

<StaticImage src="/issues/issue22/swiftui-routing-layer-sheet.gif" alt="SwiftUI Navigation Layer Sheet Demo." link="https://www.ioscoffeebreak.com/issues/issue22/swiftui-routing-layer-sheet.gif" caption="SwiftUI Navigation Layer Sheet Demo." priority={true} />

My initial Router setup handled navigation for a single screen, while my updated Coordinator-based navigation layer supports nesting, with parent Coordinators managing child Coordinators to enable complex hierarchical navigation flows throughout the app.

If you have thoughts or personal experiences with SwiftUI navigation, I would love to hear them — feel free to reach out to me on Twitter!

If you are only interested in the code, here is the GitHub repository.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

💡 Automate GitHub Tasks with GitHub CLI in Actions Workflows: A Step-by-Step Guide

Did you know that GitHub-hosted runners come with the GitHub CLI pre-installed? I wasn't aware either! By combining the GitHub CLI with GitHub Actions workflows, you can streamline tasks that typically require manual effort.

Pol's latest article dives into using the GitHub CLI with the provided token in workflows to automate tasks like creating pull requests or managing issues, reducing friction and improving efficiency.

✨ Preview SwiftUI views with bindings using @Previewable

Starting with Xcode 16, the new Previewable macro simplifies previewing SwiftUI views that use bindings.

Natalia's recent post offers a quick guide on how to apply it. This addition is highly practical, as it allows for fully interactive previews without needing to embed state within child views, streamlining the preview process.

🤯 GitHub Copilot for Xcode Uses TCA!

Recently, GitHub launched GitHub Copilot for Xcode, an extension designed to simplify using their AI assistant directly within Xcode.

In a post, Romain pointed out that this new extension runs with TCA (The Composable Architecture), making it even more appealing to developers who rely on this library. It is exciting to see increasing adoption of Point-Free's composable architecture by individuals and companies alike. What are your thoughts on TCA and its growing popularity?

✍️ Mastering TextEditor in SwiftUI: Features, Limitations, and Tips

Artem's latest article dives into the fundamentals of TextEditor in SwiftUI and demonstrates how to enhance it with added features.

This is the first article in a series focusing on text editing. Upcoming articles will delve into topics like text classification and creating custom machine learning models for text analysis. I am super excited to follow along as this series unfolds!

Views on SwiftUI's navigation are divided: some developers support it fully, while others feel it is not yet robust enough for complex apps, even with NavigationStack.

This week, I published an article introducing the Router pattern in SwiftUI, explaining why it is beneficial and how to implement it effectively. The Router pattern helps you keep navigation logic separate from your views, making your app more maintainable and scalable in the long run.

The Router approach, ideal for programmatic and adaptable navigation, offers significant flexibility. It is particularly effective for apps with complex or conditional navigation flows, allowing developers to structure navigation tailored precisely to the app's requirements.

If you are only interested in the code, here is the GitHub repository.

Here is a quick demo from the sample project I have set up:

<StaticImage src="/issues/issue21/router_navigation_demo.gif" alt="SwiftUI Navigation Demo using the Router Pattern." link="https://www.ioscoffeebreak.com/issues/issue21/router_navigation_demo.gif" caption="SwiftUI Navigation Demo using the Router Pattern." priority={true} />

The navigation router could be enhanced to handle other types of transitions, like sheet presentations or full-screen views, in addition to the navigation stack. I am planning to add these features over the next few weeks — stay tuned!

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

✍️ Automate Apple app code signing using fastlane match

Pol's article offers a friendly guide to automating code signing with Fastlane Match, covering the basics and providing a step-by-step tutorial. This can be a huge time-saver, especially for large teams, as it helps avoid redundancy and streamlines updates to signing identities when adding devices or new team members.

For teams managing certificates manually or through automation, it is a highly recommended read to minimize potential confusion and improve efficiency.

🫙 Developing in Swift with VS Code Dev Containers

Imagine if we could eliminate the "it works on my machine" issue entirely 🤔!

In the first of a three-part series, Natan from Swift Toolkit walks through using VS Code, Dev Containers, and GitHub Codespaces to develop and debug Swift applications on Linux.

This article provides a practical guide on setting up VS Code on your local machine with Dev Containers, enabling a smooth Swift development and debugging experience across environments.

🧙‍♀️ Bringing Tuist Previews forward

Testing the application is a vital part of the development process, catching bugs 🐛 early makes them easier to locate and resolve.

With Tuist's latest preview enhancements, launching the app from any branch, specific commit, or the latest repository update is now just one command away. I am definitely thrilled to give this feature a try!

tuist run App@latest # run latest preview from you default branch
tuist run App@feature-branch # run preview from a specified branch
tuist run App@91eb7c # run preview from a specific commit

This week, GitHub revealed that GitHub Copilot's code completion feature is now available in public preview for Xcode! GitHub Copilot, an AI-powered coding assistant, helps streamline and enhance your coding process. Copilot for Xcode is an Xcode extension that provides inline coding suggestions as you type.

<StaticImage src="/issues/issue20/github_copilot.gif" alt="GitHub Copilot demo from GitHub's repository." link="https://www.ioscoffeebreak.com/issues/issue20/github_copilot.gif" caption="GitHub Copilot demo from GitHub's repository." priority={true} />

Key Features:

• Code Completions: Integrated in Xcode, providing inline code suggestions.
• Multi-Language Support: Compatible with Swift, Objective-C, and other Apple ecosystem languages.
• Multiline Suggestions: Default single-line suggestions, with multi-line options accessed by holding the Option key and pressing Option + Tab.
• Content Filtering: Uses filters to prevent inappropriate content, maintaining a professional coding environment.
• Public Code Blocker: Includes a filter to block suggestions that resemble public GitHub code, preventing code duplication.

Requirements:

• macOS 12+
• Xcode 8+
• A GitHub Copilot subscription. To learn more, visit the official page.

Initial Impressions

I tested it briefly on some sample code, and it feels like a solid improvement over Xcode 16's local predictive model. It is quicker, more precise, and can auto-generate longer code snippets. I will need to spend more time with it for a thorough review, though!

While I don't see myself subscribing for a feature like this, I am always curious to explore these tools and see what they can offer!

For a guide on how to get started, check the docs from GitHub.

Now it is time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

🧜‍♀️ The Strategy Pattern

Do you aim to simplify when adding new features to existing code? This week, Vera offers her insights on using the Strategy pattern to encapsulate and swap different behaviors with ease.

My advice: take a page from Vera's playbook to avoid turning your "birds" into "merm-birds"!

P.S. You might neeed to read the article to get this one!

🚣‍♂️ Coordinators & SwiftUI

Views on SwiftUI's navigation are divided: some developers support it fully, while others feel it is not yet robust enough for complex apps, even with NavigationStack. I have to admit, my team and I currently use SwiftUI for UI design, but still handle navigation with UIKit by embedding SwiftUI views in UIHostingController — especially since we support iOS 15 and can't use NavigationStack at its full power yet!

In this article, Vitaly investigates whether SwiftUI, specifically NavigationStack, can support the Coordinator pattern. He explores adapting this approach to SwiftUI and demonstrates building a streamlined SwiftUI Coordinator without complex third-party libraries.

Vitaly also offers a video version of this article if you would rather watch than read.

🤖 How to automatically update build and version numbers in your app using Fastlane

In this article, Pol demonstrates how to use Fastlane to streamline updating your app's build and version numbers.

By automating this process, you can ensure your app's version and build numbers are always current before deploying a new release, saving time and reducing errors!

👶 Getting Started with Swift Package Manager

If you are new to Swift Packages and looking to create CLI executables or library targets, this article is a must-read! Joannis explains the essentials of Swift Package Manager, walking you through creating a package, adding dependencies, and linking target dependencies.

Interesting fact: With SwiftPM, you can choose to add dependencies by either editing the manifest (Package.swift) directly or by using the CLI tool — both approaches work seamlessly.

💡 Blog about Swift: Tips and ideas to start your own

Recently, I found an article Antoine shared a few years back that I wish I had seen when I first started blogging about Swift!

If you are already blogging about Swift or planning to start, this article shares Antoine's top tips for writing Swift content effectively. It is full of best practices, so definitely check it out!

Last week, I have been migrating our CI/CD pipelines from TeamCity to Xcode Cloud. Xcode Cloud is a Continuous Integration and Continuous Delivery (CI/CD) platform provided by Apple. It automates away the hard work of building your apps, testing them, signing them, and pushing them to a destination.

With all project external dependencies now managed through SPM, the transition to Xcode Cloud was seamless. I had just encountered some few minor issues, but they were quickly resolved.

Workflow 1: Changes to the main branch

The first workflow was set up to run unit tests on every push to the main branch and on pull requests (PRs) targeting main. Additionally, it alerts the team once all tests pass, confirming it is safe to merge into main.

<StaticImage src="/issues/issue19/xcode_cloud_workflow1.webp`" alt="Xcode Cloud workflow that runs tests and notifies the result." link="https://www.ioscoffeebreak.com/issues/issue19/xcode_cloud_workflow1.webp" caption="Xcode Cloud workflow that runs tests and notifies the result." priority={true} />

Workflow 2: Releases

The second workflow migration triggers on every push to the release/XXX/qa branch, archiving the app and distributing it to TestFlight for external testing.

To keep versioning clear, we append the version number to the branch name, formatted as release/XXX/qa/Y.Y.Y. A similar workflow was also created for archiving and uploading to production.

The XXX indicates the client brand but can be replaced by any identifier that makes sense for your project setup.

<StaticImage src="/issues/issue19/xcode_cloud_workflow2.webp" alt="Xcode Cloud workflow that archives and uploads to TestFlight." link="https://www.ioscoffeebreak.com/issues/issue19/xcode_cloud_workflow2.webp" caption="Xcode Cloud workflow that archives and uploads to TestFlight." priority={true} />

I am currently focused on migrating the remaining workflows and looking for ways to extend the existing ones. Wish me luck 🤞!

Now it's time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

🛠️ A Different Approach Using the Swift Argument Parser

Using Swift Argument Parser is quite intuitive, but sometimes you might need added flexibility for custom output or workflows.

In this post by Swift Toolkit, Natan explores advanced techniques like custom output styles and flows with protocol-driven commands. If you are into tooling and scripting, all using the Swift programming language, Swift Toolkit is the website you should bookmark!

🕶 Improve your app's UX with SwiftUI's task view modifier

SwiftUI's .task modifier acts as an asynchronous combination of .onAppear and .onDisappear, starting a task when a view appears and canceling it if the view exits first.

Recently, Peter needed to add a delay before running specific code and created a reusable DelayTaskViewModifier, inspired by Combine's functionality. This modifier allows tasks to run after a short delay, enhancing control within SwiftUI workflows.

🚫 Nitpicking during code review is just a waste of time. Invest in tooling instead.

Nitpicking can be subjective and often leads to unnecessary debates that sidetrack higher-impact issues. The true is that the line between necessary changes and nitpicking can be blurry!

Christopher suggests that nitpicking often stems from gaps in tools, automation, and conventions — a point I fully agree with! The key is to replace nitpicking with effective tooling.

For those interested in streamlining their review process, this article offers practical recommendations on tools to support your team and keep feedback productive!

Nitpicking stands as the finding or pointing out of minor faults in a fussy or pedantic way.

<StaticTweet id="1744330816560222634" />

Earlier this year, I set several personal milestones, and as we enter the final quarter, I am happy to say that the only goal I haven't hit yet is going to the gym four times a week 😅🏋🏼‍♀️! I mean, it is crazy right?

On the bright side, I have not only posted more on my blog, but I also built this newsletter from scratch, which now has over 250 email subscribers and is close to 1k unique visitors! It's been an amazing motivator to continue writing and delivering value for free to the iOS community.

This is the driving force behind it all! I have spent countless hours searching for valuable resources and often wished there was a single place to find them effortlessly. Now, there is, and it is called iOS Coffee Break ☕!

<StaticImage src="issues/issue18/plausible_metrics_till_oct_2024.webp" alt="iOS Coffee Break website metrics since May 2024." link="https://www.ioscoffeebreak.com/issues/issue18/plausible_metrics_till_oct_2024.webp" caption="iOS Coffee Break website metrics since May 2024." priority={true} />

I love sharing free content to help fellow developers. Your support means a lot! Please follow me on LinkedIn, GitHub, and Twitter. Let’s connect, collaborate, and grow together! 🚀

Now it's time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

🏎 Working at startups vs large companies

Who hasn’t dreamed of working at top companies like Apple, Google, or Amazon? I know I did... In a non-technical article, Bruno explores the differences between working for companies of various sizes, helping you figure out which type of organization aligns best with your style and interests.

I highly recommend checking out this piece to gain insights into the pros and cons of working for larger versus smaller companies.

⚠️ Why Do View Controllers Need init(coder:)?

If you have ever written a UIViewController in UIKit without Storyboards or XIBs, you have likely come across the init(coder:) error. Vera's latest article dives into why this initializer is required when creating view controllers programmatically.

If you are curious about the details behind this error and how to handle it, it is definitely worth a read!

🔍 Developer productivity boost with Google Search Tips & Tricks

One of the key skills for any developer is knowing how to perform efficient searches. This week, Antoine shared valuable tips on improving your search results using Google. These include tricks like utilizing the wildcard asterisk (*) and limiting searches to specific domains, among others.

His insights are definitely worth checking out if you are looking to level up your search game!

☁️ How to install the same version of Ruby and Fastlane locally and on CI/CD

Ensuring tooling consistency is essential for maintaining stability — making sure that every team member uses the same versions of tools and dependencies across local environments and CI/CD systems.

Pol's latest article goes through this topic and how to set up and install Ruby and Fastlane reliably with GitHub Actions. If you are interested into iOS CI/CD development topics, I highly recommend you subscribing to his newsletter.

🧱 The perfect iOS networking layer does not exist - Part 2

Every iOS developer is likely familiar with building a custom networking layer, and many have probably refactored their own network clients, as I did with mine, Carrots 🥕. The constant question remains: "Is it good enough, or can it be improved?"

In a series of articles, Calin shares his approach to creating a modular, extensible, and testable networking layer in Swift. His latest release focuses on writing unit and integration tests for components like APIClient, Middleware, and APIService — a great resource for developers at any level.

SwiftLeeds has come to a close, and I am so glad I could attend this fantastic event! It was my first iOS conference, and I couldn't have picked a better one.

Even though I went solo, I never felt alone — everyone was so welcoming and friendly. Making connections was effortless.

🚀 Big thanks to Adam and the entire organizing team for making this event happen! I have made great connections that I plan to keep in touch with, and I am already excited about next year! 👀

<StaticImage src="issues/issue17/adam_swiftleeds.webp" alt="Adam Rush hosting SwiftLeeds 2024 - Opening Ceremony 🏟️." link="https://www.ioscoffeebreak.com/issues/issue17/adam_swiftleeds.webp" caption="Adam Rush hosting SwiftLeeds 2024 - Opening Ceremony 🏟️." priority={true} />

Talks

SwiftLeeds 2024 featured a diverse range of talks, from non-technical stories like Chloe's transition from teaching to mobile development and Josh's journey of overcoming his stutter, to more technical topics such as Max introduction to WebAssembly and Matthew Massicotte's deep dive into Swift Concurrency.

Among the sessions, I have chosen a few that resonated most with me and left a lasting impact. Here is a quick look at those standout talks:

All the talks should be available soon on the SwiftLeeds Youtube channel.

From Side Project to Going Indie

Antoine kicked off SwiftLeeds with a captivating talk about his journey to becoming an Indie developer. From the developers I have met over the past few days, it is clear that most are working on side projects. However, only a small portion of them are able to earn enough from these projects to fully support themselves.

Hopefully with Antoine's strategies and insights, we can better leverage our side projects, potentially turning them into a stepping stone for a significant career shift.

Off topic, it was conducted a study on SwiftLeeds and Antoine is in fact the tallest iOS developer alive!

Cut costs, not corners - Master modularization with SPM

Antonio talk about modularization with SPM was one of the most interesting ones to me because I can totally see myself into his struggles while refactoring his monolith iOS project using SPM.

Antonio shared practical advice for working with SPM, offering helpful strategies to implement in your projects. He highlighted common pitfalls to avoid and provided guidance on maintaining SPM projects effectively over time. Unfortunately, I couldn't reach out to him at the end of the talks, but I will try to get to him to discuss some topics.

For those who attended the talk, have you found the out way of the maze?

Fixing Image Performance for The Worst iPhone

Aviel's talk covered the image performance issues his team encountered and how they tackled them. If you are interested in practical solutions, I highly recommend watching it when it becomes available.

He shared real world examples of CPU overload, OOM crashes, frame rate drops in SwiftUI, and how they managed to overcome these to maintain 60 FPS, ensuring smooth scrolling through high resolution images. It is definitely a great resource for anyone dealing with similar performance challenges!

From Quantum to Code: A Teacher's Journey into Mobile Development

Chloe Jenner's debut as a conference speaker was nothing short of remarkable, delivering a poetic and deeply inspirational talk! In a refreshing, non-technical session, Chloe shared her personal journey, transitioning from being a teacher to the fast-paced world of mobile development.

Her engaging storytelling and practical advice encouraged the audience to embrace their own career shifts, while highlighting the untapped potential of individuals from diverse backgrounds. It was one of the most powerful and motivational talks I have seen!

For anyone feeling like they "do not belong here", take a 20-minute break and let Chloe's talk change your mind!

The Roast of your App's Design

Hidde delivered one of the most entertaining talks at the conference by humorously roasting two applications that clearly lacked adherence to Apple's Human Interface guidelines. The main issues pointed out the excessive taps required for actions, intrusive onboarding processes, misuse of animations, and failure to incorporate native components.

A big shoutout to Harry and Antonio for playing along and being the subject to all kinds of dutch 🇳🇱 jokes!

As a side note, rumor has it that Harry hasn’t stopped crying since ...

Zerocam: Indie App of the Conference (Personal choice)

<StaticImage src="/issues/issue17/zerocam.webp" alt="ZeroCam App Store screenshots." link="https://www.ioscoffeebreak.com/issues/issue17/zerocam.webp" caption="ZeroCam App Store screenshots." />

I met Sergio at the conference, where we talked about his passion for photography and his app, Zerocam. It is a minimalist iPhone camera app designed without heavy post-processing or complex controls, offering an experience similar to a digital camera.

Key Features:

• Natural Photography: No artificial post-processing, just RAW photos with soft, natural results.
• One-Button Simplicity: One-button operation for hassle-free shooting.
• No Distractions: No settings or mode changes, focusing solely on capturing moments.
• Lens Switching: Quick lens change via Force Touch.
• Become a Better Photographer: Join the 365 Challenge with the dedicated widget and improve your photography skills daily.

If you would like to see more content focused on applications, let me know! You can always reach out to me on X. Feel free to connect!

NotebookLM's new podcast feature is incredible! For those unfamiliar, NotebookLM is a Google-powered AI research assistant, using Gemini 1.5 Pro to help you understand complex information. You can upload documents like PDFs, text files or blog posts, and generate derivative works like study guides or FAQs.

Now, with the new feature, you can transform that content into a podcast! You read it right! I have tested out it with my latest issue, and the results were surprisingly good. I have noticed just one small problem in the audio but bear in mind that this feature is experimental! It is certainly a unique way to view your own material from a new perspective.

Give it a listen and let me know your thoughts — would this be something you would find useful to include with the weekly issue? This way, you could listen to my weekly podcast while driving — pretty convenient, right?

<BasicAudioPlayer src="/issues/issue16/ioscoffeebreaknewsletter_issue15.wav" />

Now it's time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

✂️ Remove the background from images using a Swift CLI tool

Removing image backgrounds has always been a challenge for me, either due to a lack of photoshop skills or the poor results from free online tools.

If you have been following the newsletter, you probably know how much I love creating Swift executables. So, I decided to develop a Swift CLI tool that removes image backgrounds using Apple's new machine-learning features in the Vision framework.

My girlfriend's cat, Simba, was the perfect model for testing. If you are curious, here is a before and after comparison!

🧩 How to build a Safari extension with SwiftUI

The latest version of QReate features a fully redesigned Safari extension entirely built with SwiftUI.

Since there weren't many resources available on the topic, Pol decided to write a blog post sharing his experience. This is the guide you need to build your Safari extension so be sure to check it out if you are interested in it!

🧱 Parsing Beyond JSON with swift-parsing

Parsing goes beyond simply handling JSON from server API calls — it is about transforming unstructured data into structured formats.

In Alejandro's latest article on Swift Toolkit, he explores the depths of parsing and demonstrates its power, especially with a library like swift-parsing. If you are looking to refine your tools or dive deeper into parsing as a solution, I highly recommend giving this article a read to discover how versatile and impactful parsing can truly be!

Sharing links to your blog on social media looks much better with well-designed previews (e.g., on Twitter). These previews can be set up in various ways, often involving custom images for each post.

I wasn't happy with how my newsletter posts were displayed on Twitter. They appeared plain, lacking any image preview — just a dull, grey square. Honestly, it didn't look appealing at all. Pretty disappointing, right 😑?

<StaticHalfWidthImage src="issues/issue15/tweet_with_no_preview.webp" alt="A tweet from me with no preview." link="https://x.com/tiagodhenriques/status/1824455871381864712" caption="iOS Coffee Break Newsletter issue #11 tweet with no preview image" />

Some websites generate preview images either by using a predefined template or by creating them programmatically. Here is an example by Antoine where a preview is either based on a set template or dynamically generated through code. This is what I wanted to achieve!

<StaticHalfWidthImage src="issues/issue15/swiftlee-tweet.webp" alt="Swift Lee tweet." link="https://x.com/twannl/status/1669629139609944064" caption="Antoine tweet displaying a custom preview image" />

I realized I needed to get my hands dirty, so I created an automated system using SwiftUI and GitHub Actions to generate custom preview images for my weekly issues 🖼. This setup not only saves time but also guarantees that each post has a unique, polished look when shared on social media.

So if you are looking to add a personal touch to your blog articles, I recommend checking out the article I wrote on this topic. It walks you through the entire process step by step!

Now it's time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

🏆 Day to Day Starting 11: The ToolSet Team to win championships

Manu has returned to writing and recently published one of the most unique articles I have come across in a while. If you are into football, you will definitely enjoy it. Manu creatively picks his own starting 11, featuring productivity tools that have made a significant impact on his workflow, efficiency, and daily life.

👴 Using Characterization Tests When Working With Legacy Code

Every software engineer encounters legacy code at some point. Being able to navigate various coding environments, particularly legacy ones, is crucial.

Vera shares insights from Michael C. Feathers' book Working Effectively with Legacy Code, emphasizing the importance of a concept called characterization tests. By using these tests, you ensure that the existing code behaves as expected, which improves its readability for others and maintains consistency in future updates.

P.S. Great job with the artistic touch, Vera!

🎨 Understanding Colors and Styles in Terminal Output

When working with command line tools, visual design often takes a back seat, and most tools appear uniform and lack styling. However, that doesn't have to be the case!

In this post, Natan breaks down how you can enhance the appearance of your Swift executables by using ANSI Escape Codes. He provides a comprehensive guide on how to apply these codes to strings, allowing you to introduce styles like colors and formatting, giving your CLI tools a more polished and personalized look.

🚚 How to pass Bindings to views in SwiftUI's NavigationDestination modifier

In SwiftUI, it is typical to display a list where users can navigate to a detailed view after selecting an item. However, it may not be immediately obvious how to use bindings when working with NavigationLinks and the .navigationDestination modifier.

In this article, Pol outlines two straightforward methods that make passing a binding to the detail view seamless, offering a clear solution to this common challenge.

⌛ Swift Build Times and Module Verification...

Paulo shared an useful tip for those building Swift frameworks to significantly reduce build times. By setting ENABLE_MODULE_VERIFIER to FALSE, his clean build times dropped from 3.5 minutes to just 52 seconds 😱.

If you are working with Swift frameworks and using Xcode 16 betas, it is highly recommended to apply this build setting change for debug builds and build with timing summaries periodically for optimization insights.

The August Giveaway 🏖️ has officially wrapped up, and I had a fantastic time organizing it! I would like to extend a big thank you 🙏 to everyone who participated and a huge congratulations to the winners 🎉.

I hope the books bring you lots of value — use them to create exciting new applications, and don't forget to share your work with the community!

<StaticTweet id="1830149229353803816" />

This week, I decided to set up a guide on how to publish your app to the App Store.

Launching an app for the first time or after a long break can be breathtaking. While submitting an app to the App Store isn't as straightforward as pressing a button, it is more manageable than it seems. The first time I went through this, I was overwhelmed by all the information I was getting.

Assuming you are in the Apple Developer Program, your app follows Apple's App Review and Human Interface guidelines, declares its APIs usage in the Privacy Manifest file, and you are ready to ship, here is what to do in order to distribute your app for beta testing or to go live in the App Store.

The Apple Developer Program membership pricing starts at $99 per year, and it gives you access to other exclusive Apple developer tools and services. If you are looking for a good resource to create your Privacy Manifest file for you, here is one by Donny Wals.

1. Code signing: Setting up an iOS distribution provisioning profile and certificate

The development provisioning profile and certificate you have been using are limited to specific devices. For broader distribution to beta testers or the App Store, you will need separate distribution credentials.

To create these, visit your Apple Developer account and navigate to "Certificates, Identifiers & Profiles". Generate a Distribution Certificate for either App Store or Ad Hoc use, install it in your Mac's Keychain, then create and download a matching Distribution Provisioning Profile. Finally, integrate these into Xcode for code signing.

Initially, this process may feel tedious, but it's essential for secure app distribution. Trust me, I have been there!

2. Create an App Store Connect record for your App

App Store Connect is where Apple Developer Program members manage app submissions, updates, and post-launch features.

To create a new app record, log into App Store Connect, go to "My Apps", and click "New App". Enter key details like the app's name, primary language, bundle ID, and SKU. You will also assign user access permissions for managing the app. Once completed, this record allows you to upload your app build, add metadata, and prepare it for submission to the App Store.

3. Archive and upload your app with Xcode

To archive and upload your app in Xcode, ensure you are using a production scheme.

• Go to "Product" > "Archive" to package your app. Once the archive is created, the Organizer window will open.
• Select the archive and click "Distribute App". Opt for "App Store Connect" and follow the prompts to validate, sign, and upload your app.

After uploading, your build will be accessible in App Store Connect, ready for further processing and submission.

4. Set up your app's metadata and details in App Store Connect

In App Store Connect, under the "App Store" tab, you will find the "App Information" page where you can add languages, categories, and your app's privacy policy URL. Configure pricing, upload screenshots (in JPEG or PNG format), and provide essential details like your app's description, keywords, support and marketing URL.

Your app's description and keywords are critical so make sure you optimize them for discovery. You might take a look at this article by Rudrank where he learns ASO (App Store Optimization) for keywords.

In the "General App Information" section, upload your app's icon (1024px x 1024px), set the version number, and include copyright and contact details. Save your progress, and you will be ready to submit for review.

If you are like me and feel challenged by design work, creating an app icon might seem intimidating. I recommend exploring the introductory Sketch guides and courses to get started. That is how I managed to design the icon for my app Padel Time. Sketch is also my number one tool to create my app screenshots.

5. Submit your app for review

To submit your app for review, go to the "Build" section in your app's App Store Connect record and click "Select a build before you submit your app". Pick the build you uploaded through Xcode, then click Done and Save. Next, select "Submit for Review". You will need to complete the questions on Export Compliance, Content Rights, and the Advertising Identifier. Once done, click Submit. Your app is now in the review queue for Apple's approval process.

Typically, approval takes one to three days, and it may take up to 24 hours for your app to be available in the App Store afterward. You will receive email updates throughout the process.

If your app is approved, congratulations 🥳! You are now on the App Store. You can view downloads, sales, ratings, and reviews directly in App Store Connect.

Earlier this month, I announced a giveaway for all newsletter subscribers, offering a chance to win one of three copies of SwiftUI Picture Books by Big Mountain Studio. When I began learning SwiftUI, the SwiftUI Views Mastery book was instrumental in helping me quickly grasp the framework and best practices.

A huge thanks 🙏 to Mark for generously providing these copies and for offering valuable resources to the iOS community.

<StaticTweet id="1823786925989535927" />

To select the winners of the newsletter's August Giveaway 🏖️, I built a CLI tool in Swift called giveawaypicker. This tool pulls my subscriber list from the database, randomly selects three emails, and displays them. In this issue, I explain how to use GitHub Actions to automate the process of building the executables for macOS and publishing them as a GitHub Release.

The issue is divided into two parts: the first covers the scripts for building and bundling the binaries, and the second details a GitHub Actions workflow that executes these scripts.

I chose not to delve into the code that retrieves my subscribers list from the database and selects three random emails since it's essentially just a GET request followed by the selection of three random items. However, if you are interested, here is the code.

Script: Build for macOS

After I have written all the code, I created a directory named scripts and inside it, created a script named build-macos.sh. These were the commands to do so:

mkdir scripts
touch build-macos.sh

Then, I added the following lines to the file.

#!/bin/sh

set -e

swift build -c release --product giveawaypicker
BUILD_PATH=$(swift build -c release --product giveawaypicker --show-bin-path)
echo -e "\n\nBuild at ${BUILD_PATH}"

DESTINATION="builds/giveawaypicker-macos"
if [ ! -d "builds" ]; then
    mkdir "builds"
fi

cp "$BUILD_PATH/giveawaypicker" "$DESTINATION"
echo "Copied binary to $DESTINATION"

The script compiles the single executable target in release mode. It then uses the --show-bin-path argument to determine the location of the generated binary. Next, it defines a destination path for the executable, creates the necessary builds folder if it doesn't already exist, and finally, uses the cp command to copy the binary to that destination.

Before you test the script locally, ensure it has executable permissions by setting them up:

chmod +x scripts/build-macos.sh

Now, I can run it to check it builds and stores the binary in the correct location. This is the command to do so:

./scripts/build-macos.sh

After running the command, I can check that the binary was created at the specified location: /builds/giveawaypicker-macos.

Writing the GitHub Actions workflow

Next, I needed a GitHub workflow with the following characteristics:

• Be triggered when creating a new release in your repository.
• Execute the previous script in a macOS machine.
• Upload the build to the release page.

I first started by creating a workflow file in the .github/workflows folder:

mkdir -p .github/workflows
touch .github/workflows/build-and-release.yml

Then, I added the following lines to the file.

on:
  release:
    types: [published]

name: Build Release Artifacts
jobs:
  build-macos:
    name: Build macOS Executable
    runs-on: macos-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v3
      - name: Build macOS binary
        run: scripts/build-macos.sh
      - name: 'Upload macOS Build Artifact'
        uses: actions/upload-artifact@v4
        with:
          name: giveawaypicker-macos
          path: builds/giveawaypicker-macos

  upload:
    name: Upload release artifacts
    runs-on: ubuntu-latest
    needs: [build-macos]
    steps:
      - uses: actions/download-artifact@v4
        with:
          path: .
      - name: List downloaded files
        run: ls -R
      - name: Upload to Release
        uses: softprops/action-gh-release@v2
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          tag_name: ${{ github.event.release.name }}
          files: ./*/*
          fail_on_unmatched_files: true

To wrap the workflow, I began by setting up a job to build the macOS binary. I used the checkout action to clone the repository onto the machine, followed by running the build-macos.sh script. Finally, I applied the upload-artifact action to store the resulting binary within the workflow.

Publishing a Release

After I commited the scripts and workflow file and pushed the changes, I could then create a new release. To do this, I went to the GitHub repository, clicked on "Releases" on the right side, and selected "Create a new release". From there, generated a new tag, added a title and description for the release.

After some time, the binary appears as an asset in the release!

<StaticImage src="/issues/issue13/giveawaypicker_release.webp" alt="Giveaway Picker v0.1.0 binary in the release assets." link="/issues/issue13/giveawaypicker_release.webp" caption="Giveaway Picker v0.1.0 binary in the release assets." />

Feel free to clone the repository, use SPM to build it and run the executable:

swift run giveawaypicker -i <supabase_reference_id> -k <supabase_key>

At the end of the month, I will run the tool and announce the winners 🎉. I will reach out to the winners via email, so stay tuned!

Now it's time to dive into some iOS development topics submitted by the community. Here are this week's highlighted resources. Hope you enjoy 🙌.

✍️ Writing great release notes doesn’t need to be hard

We have all resorted to the classic "Bug fixes and performance improvements" in our app release notes. However, it is crucial to make our release notes clear and consistent! They should reflect a unified tone, be grammatically correct, prioritize changes based on user impact, and guide users on any necessary follow-up actions.

I highly recommend checking out Eli's article for helpful tips on improving your release notes and better informing your users about what's been fixed or enhanced.

🔎 SwiftUI Previewable Macro

Apple introduced the Previewable macro in iOS 18. This macro simplifies and speeds up the process of previewing views by automatically creating the boilerplate wrapper view with State bindings.

In this article from Use your Loaf, you can learn how to replace that boilerplate wrapper code with the Previewable macro.

🐙 Cross-Platform Swift: Building a Swift app for the browser

Point Free's latest series focuses on cross-platform Swift, starting with a basic guide on running a simple Swift app in a browser. This week, they released a blog post detailing how they recreated their counter feature in Swift, running it in the browser using WebAssembly.

WebAssembly is a binary format that allows running languages like Swift directly in the browser, not just JavaScript. For more details, I highly suggest you to check out their article and watch the free episodes in the series.

👨‍💻 Dev Conversations: Andrew Barba

Natan has introduced a new series on SwiftToolkit titled "Dev Conversations" featuring brief interviews with developers focused on the Swift server and tooling ecosystem. This month, he spoke with Andrew about his early career, transitioning from iOS development to backend work, and the recent release of Swift Cloud.

If you are interested in the Swift ecosystem, this series is worth following for valuable insights and perspectives from other developers.

Reference

• Releasing Swift Binaries with GitHub Actions
• Supabase Swift Client Library

As an Apple platforms developer's, your journey involves creating apps for Apple devices like iPhone, Apple Watch, Apple TV, and more. Developers use specialized tools to design, build, test, and deploy these apps. The right combination of these resources helps companies and individuals to deliver high-quality apps that function smoothly across the Apple ecosystem.

To help you with this process, here are my must-have set of tools that can benefit you as an Apple platforms developer divided by categories.

The tools I have included in this issue aren’t sponsored in any way. Most are ones I personally rely on daily, while others are featured based on positive feedback from the community.

1. Integrated Development Environments (IDEs) and Editors

To write code, we need an integrated development environment (IDE).

Xcode is usually the top choice because it is built by Apple and includes everything required for iOS, macOS, watchOS, and tvOS development. It is the go-to tool for many developers, including me, since it is optimized for Apple's platforms and seamlessly integrates with Cocoa and Cocoa Touch frameworks.

However, you can also explore alternatives like AppCode and VSCode.

<StaticImage src="/issues/issue12/xcode.webp" alt="Xcode for Padel Time." link="/issues/issue12/xcode.webp" caption="Xcode for Padel Time." />

Xcode is my only choice for writing code. Yeah, I know that sometimes it does crash, but it is the best IDE for designing, coding, testing and debugging apps.

2. Testing and Debugging

There are several testing and debugging tools available to help developers release high-quality iOS apps with minimal bugs and errors.

Instruments, integrated within Xcode, is a performance analyzer that helps you profile apps for various Apple platforms, allowing early identification of issues during development.

Proxyman is a modern, native and web debugging proxy for macOS, letting you inspect HTTP and HTTPS traffic between your device and the internet. Alternatives include Charles Proxy and Postman, which serve similar functions for traffic inspection and debugging.

3. Automation, Continuous Integration and Continuous Delivery (CI/CD)

CI/CD tools greatly enhance deployment efficiency for iOS developers by automating repetitive tasks like releases, code signing, and screenshot generation.

Fastlane, an open-source platform, streamlines deployment processes by automating everything from taking screenshots to submitting apps to the App Store. It integrates smoothly with CI services. Popular alternatives include Jenkins and Codemagic.

Xcode Cloud offers a built-in Apple solution for continuous integration and delivery, providing tools for app building, automated testing, and feedback management. TeamCity is another CI/CD option offering robust features for development workflows.

An Apple Developer Program membership includes 25 compute hours per month of Xcode Cloud usage which should be enough to get your app up and running.

<StaticImage src="/issues/issue12/xcode_cloud.webp" alt="Xcode Cloud workflows for Padel Time." link="/issues/issue12/xcode_cloud.webp" caption="Xcode Cloud workflows for Padel Time." />

4. User Testing and Distribution

After crafting your amazing app, gathering feedback and identifying potential crashes through user testing is essential.

TestFlight by Apple allows you to invite up to 10,000 testers via email or a shared link, making it easy to gather feedback before launching on the App Store. Testers can provide insights, including screenshots or crash details, directly from the app.

Other options include Firebase App Distribution and TestFairy, which offer similar beta testing solutions but are not first party solutions to developers.

5. Design and Prototype

Design and prototyping tools are essential for iOS developers in building the UX/UI of their applications.

Sketch is a leading tool for creating and editing vector graphics. I often use it myself for designing user interfaces for my mobile apps and websites.

<StaticImage src="/issues/issue12/sketch_padeltime.webp" alt="iPhone App Store screenshots for Padel Time 1.2.0." link="/issues/issue12/sketch_padeltime.webp" caption="iPhone App Store screenshots for Padel Time 1.2.0." />

Its collaboration features, like Sketch Cloud for syncing and sharing, make teamwork easier.

Other popular options include Adobe XD, which has received positive community feedback, though I haven't personally used it. You can also explore AI-driven design assistance tools like ChatGPT or Claude 3.5 Sonnet for creative input.

If you are like me and feel challenged by design work, creating an app icon might seem intimidating. I recommend exploring the introductory Sketch guides and courses to get started. That is how I managed to design the icon for my app Padel Time. Sketch is also my number one tool to create my app screenshots.

6. Other Developer tools

Homebrew is a free, open-source package manager designed to streamline software installation on macOS. Once installed, Homebrew allows users to easily download and set up software from its large repository, which includes thousands of packages like Fastlane.

If you are not aware, you can contribute and add new software to the Homebrew repository. For more intructions, check out their official guide.

SourceTree is a Git client with a graphical interface, making it easier to manage code repositories without relying on command-line tools. It provides a smooth way to interact with your projects by enabling you to perform tasks like cloning, committing, and managing branches visually. If you prefer alternatives, you can try Fork (which is paid) or Xcode, which has built-in Git source control integration.

I usually stick with Xcode and its Git support for basic tasks but switch to SourceTree when handling more complex merge conflicts.

Docker is a tool designed for running applications in containers, which offer similar isolation and security as virtual machines but are more lightweight because they share the host system's OS. With Docker, you can easily deploy and scale applications across different environments while ensuring consistency in how your code runs.

If you work with Server-Side Swift, Docker is especially beneficial since many servers operate on Linux, making it a reliable solution for testing and deploying your applications in a production-like environment.

Uff, that was a lot! Hope that you find here tools that can make your life easier as an Apple developer. Now it's time to dive into some iOS development topics. Here are this week's highlighted resources. Hope you enjoy 🙌.

🧗‍♀️ How I switched from QA to Senior iOS Developer

Trust in your potential and don't let others define your limits, and this extends beyond just programming. Vera's article is a great source of inspiration, encouraging everyone to chase their dreams, stand up for what they want, and realize their full potential.

Start by taking small steps in a secure environment, like at home, where it is safe to fail and learn. From there, gather the resources to move forward. Ultimately, your growth and success are in your own hands 👐!

☁️ Getting started with Xcode Cloud

Xcode Cloud offers an easy-to-use CI/CD platform specifically designed for Apple applications. If you are new to Xcode Cloud, I highly suggest exploring Darryl's detailed guide, which walks you through setting it up, creating a build workflow and configuring post-build actions to receive notifications about your workflow results. It is a great resource to help you smoothly get started with Xcode Cloud and make the most of its features.

✅ Upload iOS apps to TestFlight with GitHub actions and Fastlane

The third and final part of a tutorial series on creating an iOS CI/CD pipeline is now available! In the earlier parts, Artur from Bright Inventions covered building and testing an app locally using Fastlane, and then setting up GitHub Actions for these tasks.

In this part, Artur demonstrates how to upload an app to TestFlight using GitHub Actions alongside the Fastlane Match tool. You will also learn how Fastlane Match works and how to securely pass sensitive data like API keys and tokens in GitHub actions workflows without exposing them in the codebase.

Running a newsletter is challenging but immensely rewarding. It enhances your knowledge, builds connections, and allows you to help others. The iOS Coffee Break Newsletter has been live for almost three months, and it is one of the best career decisions I have made despite balancing it with my full-time job.

Here are some strategies that keep me motivated in my side project. These points are what work best for me, but I hope you can relate to some of them.

1. Dedicate daily time to your side project

For me, I dedicate a small part of my day to staying updated with the latest community news. I usually take notes or bookmark articles that I might want to feature in that week's issue. At the end of the week, I review everything and pick what is most relevant at the time. If your side project is focused on coding, it is helpful to set aside a short amount of time each day to work on improvements, build features, or fix bugs.

2. Engage in activities outside work

For me, staying active is key! Exercising helps me unwind after a long day, and it is also great for boosting brain function. I have been playing Padel with colleagues from work once or twice a week and hitting the gym 2-3 times a week. If sports aren't your thing, find another activity that brings you joy — whether it is playing an instrument, learning a new language, cooking, meditating, or something else entirely. The important part is doing what makes you feel good.

3. Set clear long-term goals for your project

Where do you want to be six months from now? It is essential to have a clear vision to effectively plan the steps needed to get there. For example, I am aiming for 500 subscribers by this year's end, which requires consistent effort. Whether that is gathering feedback or analyzing metrics to see what content resonates most with your audience, success requires ongoing dedication and strategic planning.

4. Celebrate every win, no matter how small

Even minor achievements can be meaningful! For example, I was thrilled when I hit my first 50 followers and received the initial community submissions. Share these milestones with others — whether through X or other platforms — connect with people, and track your growth along the way.

Now it's time to dive into some iOS development topics. Here are this week's highlighted resources. Hope you enjoy 🙌.

🏋️‍♂️ Building a personal brand to elevate your iOS career

iOSKonf recently uploaded this year’s talks on YouTube, and one by Rudrank grabbed my attention. He discussed his journey to building a personal brand and becoming indie, offering valuable tips for advancing your iOS career and gaining visibility in the iOS community.

One key takeaway was a Rudrank's quote: "The best possible marketing you can do is to add value to other people's lives." This aligns with why I created this newsletter — to share knowledge and build connections by contributing to the community through content and resources.

✂️ Removing image background using the Vision framework

This week, Matteo from Create with Swift shared an insightful article on using the VNGenerateForegroundInstanceMaskRequest API, part of the Vision framework, to simplify background removal in images. I have often found myself struggling with design tools for this task, so this API is a game-changer.

The process involves three main steps: generating a mask from the image, applying that mask to isolate the subject and then converting the result into a displayable format in the UI. This approach streamlines what was once a complex task into a more manageable process.

⌛ Concurrency Step-by-Step: A Network Request

Matthew Massicotte, an experienced Apple platforms developer, recently published an in-depth article on making network requests with SwiftUI. He explores various techniques, diving deep into how network requests function while showcasing the power of MainActor and its interaction with Swift concurrency.

The article also highlights how to effectively use the nonisolated keyword to manage actor isolation and prevent unwanted behavior. Matthew’s insights are especially valuable for developers eager to master Swift concurrency and I really look forward to meet him at Swift Leeds and hopefully gain deeper insights into how Swift Concurrency works.

🤲 An initial hands-on with SwiftCloud

This article by Swift Toolkit.dev offers an introductory guide to SwiftCloud, showing you how to deploy two Lambda functions to AWS with live examples. Andrew Barba's new open-source package handles the setup seamlessly—it builds the targets using SPM, uploads them, and manages resource creation if needed. I have previously used SwiftCloud to deploy Swift apps on Vercel, so I am eager to test out this new integration with Lambda functions. And the best part is that you can also use the WebServer component to deploy any existing Hummingbird or Vapor application!

🚀 Ship your indie apps in hours, not days!

Last month, Pol shared exciting news about transitioning fully into freelancing, indie app development, and content creation. He is kicking off September with a new workshop titled "Ship your indie apps in hours, not days!" The 3-hour session is packed with tips, tools, and CI/CD workflows.

I have been following Pol’s work for around a year, and his insights have helped me automate tasks and migrate our CI/CD pipelines to Xcode Cloud. Be sure to mark your calendar for this event 🗓️!

This week, I was thrilled to hear about RevenueCat's hackathon, Ship-a-ton. The challenge is to launch an app on the App Store or Google Play Store, using the RevenueCat SDK for in-app purchase monetization. I am considering this as the perfect chance to finally bring an old app idea of mine to life and release it within 30 days. Let's see if that short timeline works out!

On a different note, Swift Leeds just revealed an exciting lineup of speakers. Which one are you most looking forward to hearing?

Now it's time to dive into some iOS development topics. Here are this week's highlighted resources. Hope you enjoy 🙌.

🤖 Releasing Swift Binaries with GitHub Actions

Curious about how to automate the release process for Swift executables using GitHub Actions and GitHub Releases?

In recent weeks, Natan, the curator of Swift Toolkit.dev explored various methods for building Swift binaries across different operating systems and architectures. This week, he takes it a step further, showing how to leverage GitHub Actions to automate the building of executables for both macOS and Linux, and then publish them directly to a GitHub Release in your repository.

🖼️ App design: 5 benefits of using system components

Creating custom elements and bypassing the often mundane system components in app design might initially seem appealing.

However, these system elements come with several advantages that are easy to overlook, potentially causing you to miss out on built-in functionalities. In Antoine's latest article, he outlines five key benefits of utilizing system components: built-in accessibility, user familiarity, accelerated design process, consistent design that leads to a better user experience, and optimized affordance — all provided at no extra cost.

When your app designer sends you a highly intricate UI that seems like it will take ages to implement, I highly recommend sharing this article with him — I am sure he will love it 🤣!

👴🏻 How Senior Developers Fix Problems

As a developer, you have probably faced problems where you thought, "I wish I had a Senior developer to consult..." or wondered, "How would a Senior developer tackle this?" I know I have, many times.

Vera, an iOS developer from 🇵🇹, wrote an insightful article on this very topic, outlining a personal framework she uses to solve problems, whether they are software-related or not. I wish I had come across this article six years ago when I first started iOS development. Back then, I often felt discouraged when I got stuck and questioned whether I was cut out for software development.

Now, with more experience under my belt, I understand that struggling with challenges is part of the process. While my experience might help me overcome some obstacles, I also know it is perfectly okay to seek help after exhausting my options.

I am setting aside space in the newsletter for developers and brands to showcase their products or ideas, with more details coming next week.

I am excited to kick off this new format by highlighting Antoine's latest course. It was a pleasure to chat with him, and I couldn't be happier to share his newest adventure!

Enough about my week, let's dive into some iOS development topics, shall we? Here are this week's highlighted resources. Hope you enjoy 🙌.

🚀 Deploy server side Swift applications on Vercel

Vercel offers a comprehensive solution for front-end developers to deploy their applications using modern best practices. It integrates seamlessly with GitHub to deploy every commit and provides features like a fast CDN, preview deployments, API routes, local testing environments, and more.

I have chosen Vercel to host all my JavaScript-based websites because of these robust capabilities. Thanks to Andrew, we can now also deploy serverless Swift applications, including websites and APIs, using Vercel. In his article, Andrew demonstrates his work on a Swift runtime and a SPM plugin that simplifies deploying Swift applications on the Vercel platform. Great job by Andrew and other contributors!

📔 Xcode File Headers and Macros

Ever wanted to customize the default comments at the top of every file created in Xcode?

In this video tutorial, Stewart demonstrates how to create your own version of the Xcode File Header. These comments are crafted from a mix of text and text macros, defined in a property list file called IDETemplateMacros. This file must be placed in one of five specific locations to be recognized. For those who need to share this file across multiple Macs, Stewart also offers a solution using iCloud Drive and symbolic links.

➡️ Navigation Patterns in SwiftUI

Navigating in SwiftUI applications has always been a bit challenging. Initially, SwiftUI introduced NavigationView, which was simple to use for basic list navigation. However, implementing programmatic navigation was quite tricky. I recall my early days with SwiftUI and how straightforward it was to set up basic list navigation, but programmatic navigation was another story.

With iOS 16, NavigationView was replaced by NavigationStack, which improved navigation by enabling dynamic and programmatic routing. In his article, Mohammad Azam delves into common navigation patterns that are useful when building SwiftUI applications, providing insights into how these new navigation tools can be effectively utilized.

Since our office is in Aveiro, we took advantage of the good weather ☀️ and headed to a beachside bar 🏖️. We enjoyed plenty of food, drinks, music and fun activities like target archery, beach volleyball, and karaoke. I find these events crucial because they bring people together (we miss some human interaction with remote work right ?) and help build stronger bonds among team members. What kinds of team-building events have you attended? Let me know!

Enough about me, let's dive into some iOS development topics, shall we? Here are this week's highlighted resources. Hope you enjoy 🙌.

🧰 Async await in Swift: The Full Toolkit

Jacob from Emerge Tools has written an article that delves into the tools available in Swift Concurrency, explaining when and how to use them. This well-crafted piece quickly became one of my top reads on the subject, thanks to its clear, concise explanations and practical code examples. Jacob begins by discussing the theoretical aspects where necessary and, for each tool, concludes with a context where it might be the ideal solution. If you are looking for a thorough yet straightforward guide on Swift Concurrency, this article is a must-read 🔥!

For those seeking a more introductory overview on the topic, check out my guide on Swift Concurrency!

⛔ Memory consumption when loading UIImage from disk

Loading images from disk into an in-memory array can significantly increase memory usage. In Antoine's latest article, he discusses techniques to optimize memory consumption: by rewriting code to use non-system caching APIs and implementing an NSCache-based solution for apps requiring image processing, you can drastically improve your app's memory efficiency.

📓 Using @DebugDescription in Xcode 16

Debugging custom types can be challenging, but having clear and informative debug output is crucial for understanding your code's behavior. The CustomDebugStringConvertible protocol and the new @DebugDescription macro in Xcode 16 can greatly assist with this. In Aryaman's article, you will learn how to effectively use this protocol and macro to simplify and enhance your debugging process.

🧞 Exploring Indie Life: Reducing Friction by CI/CD

Manually shipping apps is a tedious and repetitive task that Rudrank believes should be automated as soon as possible. He fully embraces the "automate first, code later" principle, which he says has greatly reduced the friction of shipping apps. In this article, Rudrank leverages the free minutes of his Xcode Cloud Apple Developer membership to push builds simultaneously to three platforms: iOS, macOS, and visionOS.

👷 Building Swift Executables

You have developed your Swift CLI executable, and now you are wondering how to make it available to other people? In this article, Swift Toolkit.dev covers key considerations and provides detailed build instructions, including how to create universal binaries and support Linux.

Although the article doesn't mention Windows support, I outlined a solution from a previous project. Using GitHub Actions, I built a CLI executable in a Windows environment, uploaded the artifact to the Action run, and downloaded it from there.

I couldn't be more thrilled, as this will be my very first iOS conference. I was waiting to hear back from my company about covering some of the conference and travel expenses, and thankfully, everything worked out. I am really looking forward to meeting the developers I follow on Twitter and sharing ideas. Will you be there too? I would love to buy you a coffee ☕!

Enough about me, let's dive into some iOS development topics, shall we? Here are this week's highlighted resources. Hope you enjoy 🙌.

🗓️ Daily insights on TCA

If you are using or interested in The Composable Architecture (TCA), you should definitely follow Romain on LinkedIn. Romain shares daily insights and personal experiences to help you master TCA 🚀. For those looking to enhance their TCA skills, check out his free interactive tutorial on TCA best practices.

⭐ How to (consistently) get 4.8* App Ratings

Jacob wrote an article some time ago on how to improve your review score with two straightforward strategies: requesting reviews and pinpointing your "wow" moment. I found his insights incredibly valuable, especially since I have struggled to get positive reviews for my side project, Padel Time. Now it is time to apply these tips and see the results!

🦎 Blend Modes in SwiftUI

Experimenting with blend modes in SwiftUI can greatly enhance your design's visual impact. In this article, Aryaman demonstrates how applying various .blendMode() modifiers to a standard view can yield intriguing and creative results.

🤖 Build and Run iOS App Tests with GitHub Actions

Last week, Artur from Bright Inventions set up a Fastlane lane to run tests locally. This time, he extends that work by creating a GitHub Actions pipeline, which triggers on changes to the main branch using the same Fastlane lane.

💻 Why macOS Development is Perfect for Indie Developers

For those of you aiming to become indie developers, Antoine has an excellent article that makes macOS development more approachable. In this piece, Antoine invites Jordi Bruin to share his journey into macOS indie development.

On a different note, Euro 2024 is nearing its climax! After some underwhelming matches, Spain 🇪🇸 and England 🏴󠁧󠁢󠁥󠁮󠁧󠁿 will face off tomorrow in the highly anticipated final 🏆! Who are you cheering for?

💻 Using SwiftUI in Command Line Tools

SwiftUI's ImageRenderer class offers a straightforward and intuitive API for exporting any view as an image. In his latest article, Swift Toolkit.dev demonstrates how to utilize this feature within a Command Line Tool to add badges to an app icon.

📖 SwiftUI Advanced Learning

This week, I stumbled upon Nick's YouTube channel, Swiftful Thinking, and started checking out some of his playlists. I have already watched the first eight videos from the Swift Advanced Learning series, where he dives into advanced topics like building custom views, animations, transitions, and using generics. I will definitely finish the series when I have more time because Nick covers valuable SwiftUI topics.

🚀 Building and Running iOS App Tests Locally with Fastlane

If you are hoping to kickstart your app development journey and run tests locally with Fastlane, check out Artur's step-by-step iOS CI/CD tutorial. The first part is already available, with two more articles on the way!

🔎 Swift Testing support for SnapshotTesting

Point Free has just released an update (version 1.17.0) for their popular SnapshotTesting library, now supporting the new Swift Testing framework alongside their MacroTesting library. If you are using these libraries and are unsure about how to migrate to the new releases, be sure to check out their informative article, which includes useful examples to help you get started.

🆕 Check if your app has a newer version on the App Store using Swift

Pol and Hidde recently built a feature for Helm to let users know when a new version of your app is available. Pol decided to dive deep and explore all the ways you can do this in his latest article.

Here are this week's highlighted resources. Hope you enjoy 🙌.

👨‍🔬 Swifter and Swifty: Mastering the Swift Testing Framework

This week, I discovered Xu Yang's blog, and I am amazed 😮 I hadn't found it sooner given the high quality of the content. In this article Xu, that writes articles under the name Fatbobman, explores the features, usage, and unique aspects of the Swift Testing framework, highlighting how it helps developers write test code more quickly and in line with Swift programming practices.

🔨 The Interactive Swift Argument Parser Guide

Planning to build your next command line tool? A few months ago, Swift Toolkit.dev published a three-part guide on leveraging the Swift Argument Parser to create new tools. The first part covers the basics: creating a new tool, commands, subcommands, and arguments. The second part dives into flags, name specifications, flag inversions and enumerable flags. The third and final part explores options and exiting. In my opinion, this guide is one of the most comprehensive resources on the Swift Argument Parser, so I highly recommend you checking it out ✅!

⏩ Useful Aliases for Everyday iOS Development

In this article, Aryaman shares several useful aliases for Xcode, CocoaPods, Git, and more to streamline your workflow. These tips aim to reduce context switching, allowing you to focus more on coding and less on managing tools.

🎮 How I Overcame My Perfectionism Through Stardew Valley

Vera decided to share a personal milestone: learning to cope with her perfectionist mindset. She writes about the open-ended country-life RPG, Stardew Valley, and how playing it offered her new perspectives. I can completely relate to her experience, as I have also felt like I could and should have done better at a task, only to end up procrastinating and doing nothing!

Yesterday, I had the chance to attend to Pol's Xcode Cloud workshop, and it was 🔥. He revealed some behind-the-scenes magic 🪄 and gave a comprehensive overview of how Xcode Cloud operates. We explored practical use cases on his app QReate, including setting up dependencies, creating CI/CD workflows to run tests, uploading the app to external services, generating release notes, and much more! The three hours flew by, and I can't wait to apply all the knowledge I gained!

I am also thrilled to announce that I received my first submissions to the platform, and I am super happy to feature them in this week's issue! Hope you enjoy 🙌.

👋 Say Goodbye to XCTest

Swift Testing has emerged as one of the standout features from WWDC24. Apple's new framework will be the default when creating a new project starting from Xcode 16. Vera’s latest article offers a comprehensive overview of this new framework, showcasing code examples that illustrate how features like tagging and parameterized testing work.

🆕 New ScrollView SwiftUI API

This week, Thomas tweeted about the new ScrollView SwiftUI API in iOS 18, sharing a code snippet that demonstrates how to easily hide the navigation bar and the tab bar when scrolling. This is achieved using the onScrollPhaseChange view modifier in combination with the toolbarVisibility method. At work, I had previously achieved this effect using UIKit’s intricate methods, but now with SwiftUI, it can be done with just a few lines of code 😮.

🔍 SwiftUI Hero Animations with NavigationTransition

With the introduction of the NavigationTransition protocol in iOS 18, implementing a hero animation in SwiftUI takes just three lines of code. I mentioned this new feature in last week's article, but this article takes this new API to a whole new level. Peter's article will guide you through creating a hero animation similar to the one in the App Store’s Today view and show you how to turn it into a reusable SwiftUI component.

🧙‍♀️ Demystifying Explicitly build modules for Xcode

One of the new features in Xcode 16 is called explicitly built modules. Despite its abstract name, this feature enhances build speed and makes compiler errors more informative. This bitrise article delves into how this feature works and the advantages it offers to projects that adopt it. While the benchmarks discussed do not show performance improvements yet, we may see more accurate results with the final release of Xcode 16.

🌟 Multiplatform Compose + SwiftUI = The Native App Future

Blending Compose UI and SwiftUI on iOS offers app developers the opportunity to create mostly-native experiences from mostly-shared Kotlin. Touchlab gives a 1-hour live stream event showcasing advanced Compose MP + SwiftUI techniques. I got to admit that I am skeptical about cross platform tools but I am willing to give it a try! If you are interested to join, do it now because the workshop is tomorrow!

🗓️ Upcoming iOS Conferences 2024

As iOS developers,WWDC24 is the conference we eagerly anticipate each year. Now that it has concluded, let's look forward to the upcoming developer conferences. iOSDevUK, NSSpain, Swift Leeds, DO iOS, and more are on the horizon! I am really excited and hopeful to attend my first conference this year and have a chat with some of you, fingers crossed 🤞!

👷 Getting Started with Swift Testing

If you got excited about Swift Testing, Apple's new macro-based testing library, like I did, you should definitely take a look at Pol Piela’s latest article. Last week, Pol wrote an article about how you can get started using it and how you can migrate your existing XCTest tests to the new library. I personally enjoy this new method of writing tests, and I believe it will finally make the process enjoyable for me.

👀 What is new in SwiftUI after WWDC24

Majid provided an excellent article exploring the latest features introduced in the SwiftUI framework. He covered topics as the new overloads for Group and ForEach views, the enhanced tab bar experience, hero animations, scroll position handling, the entry macro that allow us to quickly introduce environment values, focused values, etc, without boilerplate, previews and its new @Previewable macro, and more.

🎨 Mesh Gradient Creator

I have been following Stewart Lynch's YouTube series for a while, and once again, Stewart has provided an excellent resource to the community. To better understand the new Mesh Gradient view introduced at WWDC24, Stewart developed a Mac app that lets you experiment with the grid of points, their coordinates, and colors. I highly recommend downloading the app, as it offers an option to either save the code for use in your own projects or to download a desktop image based on your creation.

🔍 Zoom navigation transition in SwiftUI

WWDC24 introduced a variety of updates, with SwiftUI receiving significant enhancements. One notable addition is the new NavigationTransition protocol, which includes the zoom transition. Thoomas Vahter illustrates this feature with a grid view example that opens a DetailView using the zoom transition. To achieve this effect, you can simply apply the navigationTransition view modifier to the destination view and the matchedTransitionSource view modifier to the originating view.

💨 Enhance replace transition for SF symbols in iOS 18

iOS 18 introduces a new feature for the ReplaceSymbolEffect called MagicReplace. This option enables smooth animations for slashes and badges in SF Symbols, improving visual transitions in your apps. Natalia Panferova showcases this feature with an example of a notification toggle, resulting in a seamless magic replace animation on the bell icon when the slash is added or removed.

💻 Helm for App Store Connect

This is the only topic outside WWDC in today's issue, but I really want to highlight it! Pol Piela and Hidde van der Ploeg released Helm last week, a native macOS app designed to make using App Store Connect easier and more enjoyable for shipping apps and updates. I am super excited to try it out and can't wait to upload a new build without needing to open App Store Connect to double-check anything!

Conclusion

Apple WWDC 2024 has set the stage for another exciting year within the Apple ecosystem, and the iOS community has quickly begun diving into these new features. I hope you enjoy the post. Feel free to follow me on Twitter and ask any questions you have related to this content. Thanks for reading, and see you next week!

The highly awaited WWDC 2024 has just wrapped up, and Apple has once again introduced a series of groundbreaking announcements set to transform the tech industry. Here is a brief overview of the major highlights from this year's event. Hope you enjoy 🙌.

This issue is somewhat beyond the focus of this newsletter, but following an incredible week at WWDC, I would like to express my gratitude 🙏 to the initial subscribers by providing a summary of the key highlights that I believe are most important for Apple developers.

Introduction of Apple Intelligence

The next big step for Apple is here. Apple Intelligence is a personal intelligence built into your devices to help you write, express yourself, and get things done effortlessly. It is deeply integrated into features and apps across the system, and built with privacy from the ground up.

Apple Intelligence starts with Apple's on-device foundation model and it is extended to the cloud with Private Cloud Compute to run larger foundation models.

Writing Tools, Genmoji 🥳 and Image Playground

Writing Tools, Genmoji and Image Playground are three powerful new Apple Intelligence features that will for sure delight users by integrating these into your apps.

Writing Tools aim to help users rewrite, proofread and summarize text. The cool thing is that if you are using any of the standard UI frameworks to render TextFields, TextViews, your app will automatically get Writing Tools! If you want to customize how your app behave while Writing Tools is active, you just need to use Apple's new TextView delegate API.

Genmoji opens up entirely new ways to communicate, letting users create a new emoji to match any moment.

The new Image Playground API delivers a consistent and easy-to-use experience. With this API, users can edit the prompt supplied to them to create an image that represents anything they want that is unique and can be stored on device. I am really excited about this because I can already see lots of useful use cases to work on! 💪

Xcode 16, Code Completion and Swift Assist

Xcode 16 has many new features to make you more productive and improve the quality of your apps. Things like a single view of your backtraces, showing relevant code from all stack frames together, deeper insight into your app's performance and enhancements to localization catalogs. Xcode 16 also marks a whole new chapter for development, as Apple infuse its tools with the power of Generative Models.

Code Completion is an innovative new engine that can predict the code you need. It uses your project symbols to customize suggestions. It runs locally on your Mac, keeping your code private, giving you super-fast results, and even works when you are offline. Xcode can even use the comments you write as context, given you a suggestion as soon as you start typing.

Swift Assist is a companion for all of your coding tasks and I have to say, one of my favorite announcements this year! Swift Assist can answer your coding questions and help with tasks like experimenting with new APIs. Like code completion, Swift Assist uses details from your project, including symbols and the relationships between them, to create personalized code.

My concern here is somehow my information is exposed to train machine learning models for example, and I don't want that for sure! However, Apple states that all of these tools are built with your privacy and security in mind. Swift Assist will be available later this year and I can't wait to try it out ✨.

Swift, Swift 6 and Swift Testing

Apple is working with the open source community to bring Swift to more platforms and domains. Swift is given support for Visual Studio Code and other editors. Linux support was expanded to include more distributions and the Windows support for Windows was also improved.

Swift 6 makes concurrent programming dramatically easier by introducing data-race safety. Other developments include improvements to concurrency, generics, and a new "Embedded Swift" subset for targeting highly-constrained environments like operating system kernels and microcontrollers.

Another important aspect of software development is writing tests. Swift Testing has expressive APIs that make it simple to write tests. Swift Testing also includes a flexible tagging system to help you organize your tests and test plans. With tags, you can selectively run tests across your test suite, like tests that use a certain module or that run on a specific device. You can easily parameterize tests so that they can be reused multiple times. Xcode 16 has full support for Swift Testing.

SwiftUI Previews and Interoperability between UI frameworks

This year, Apple has focused on previews, customizations and interoperability. Xcode Previews has a new dynamic linking architecture that uses the same build artifacts for previews for when you build-and-run. This avoids rebuilding your project when switching between the two, making for a dramatically smoother and more productive workflow.

A new @Previewable macro makes it possible to use dynamic properties like @State directly in a Xcode Preview, making much more easier to set up SwiftUI previews.

Many apps adopting SwiftUI also use views written with UIKit and AppKit, so great interoperability with these frameworks is critical. Now, UI frameworks share more common foundations. Gesture recognition has been factored out of UIKit, enabling you to take any built-in or custom UIGestureRecognizer and use it in your SwiftUI view hierarchy.

Also, animations have been factored out of SwiftUI so you can now set up animations on UIKit or AppKit views and them drive them with SwiftUI, including fully custom animations.

iOS and iPadOS 18

iOS is more customizable than ever, and it starts with Controls. They make getting to frequent tasks from your apps faster and easier and are a great way to engage with your app from more places across the system.

iPadOS delivers big updates to the ways that your users interact with your apps, starting with the redesigned tab bar. It floats at the top of your app and makes it easy to jump to your favorite tabs. Additionally, it turns into a sidebar for those moments when you want to dive deeper. The most interesting feature for iPadOS for far!

WatchOS 11 and macOS Sequoia

One of the coolest new features on watchOS this year actually starts on iOS: Live Activities. Watch wearers will see your compact leading and trailing views automatically in the Smart Stack, as well when significant event notifications occur. You can now bring your interactive widgets to watchOS, using the same APIs your are currently using on iOS and macOS.

App Intents let you create widgets with multiple interactive areas that perform actions and update state directly in the widget.

And for those of you eager to integrate double tap into your apps, handGestureShortcut is the modifier you have been looking for. Use this modifier to identify a Button or Toggle as the primary action in your app, widget or Live Activity to give your customers quick, one-handed control.

This year, macOS supports Apple Intelligence with features like Writing Tools, Genmoji and Image Playground that you can integrate right into your apps to create engaging experiences. It also introduces productivity features like easier window tiling, iPhone mirroring, and delivers news APIs including user space file system support and major improvements to MapKit.

Conclusion

Apple WWDC 2024 has laid the foundation for another thrilling year within the Apple ecosystem. With revolutionary updates spanning iOS, macOS, and new explorations into AR and health, Apple is once again pushing boundaries, equipping developers with state-of-the-art tools and delivering unmatched experiences to users. Stay tuned for more in-depth coverage and tutorials on how to leverage these new technologies in your projects!

Example Issue Template

Hi there, welcome to the 1st issue of iOS Coffee Break Newsletter. Today we will dive into how modern concurrency in Swift works, how we can easily get started building Server-Side applications in Swift and take a look at Padel Time, an iOS/watchOS application, designed to help Padel players to keep track of their scores. Hope you enjoy 🙌

How to bridge completion handlers into async APIs 🫱🏾‍🫲🏻

In this article, Tiago does show you how to use continuations to bridge his old completion handler code into the new async APIs.

The author presents an example of an HTTP GET request that fetches a list of posts. He then begans by defining a callback-based function and then, writes a second version of that same function using an async-await approach based on continuations.

How to deploy a Vapor application ☁️

Last month, Tiago did a series of articles on the work he did to explore how Vapor works. Vapor is a Server-Side Swift framework that leverages the power of Swift to make routing type-safe.

The author shows a deployment that runs locally using Docker an how you can deploy your Vapor application on a server so it becomes publicly available.

Meet Modern Concurrency in Swift ⏳

Last year at work, Tiago felt the need to replace some parts of his codebase to adopt the new Modern Concurrency APIs in Swift.

So, in this short article, the author had prepared a getting started with modern concurrency guide, where he showcased how to fetch a list of articles asynchronously and how to can make use of grouped tasks to optimize performance.

Increment build number using Fastlane ⬆️

I like reading articles like this one where code authors and maintainers use CI/CD workflows to automate tedious tasks to save time and effort and reduce the chances of making mistakes.

In this case, Tiago Henriques goes through how you can improve your CI/CD pipeline to increment the build number using Fastlane.

Padel Time, Your Score Tracker Companion 🎾

<StaticImage src="/issues/issue1/padeltime3.png" alt="Padel Time - Your Score Tracker Companion." link="/issues/issue1/padeltime3.png" caption="Padel Time - Your Score Tracker Companion." />

Today, we are looking at Padel Time by Tiago Henriques.

With seamless point counting on your Apple Watch, Padel Time ensures precision and eliminates disputes, leaving you to focus on the game. As simple as raising your arm and clicking on the winning team on each point.

Here are some important features:

• 🎾 Count your points
• 📈 Track your progress anytime
• 🏋️‍♀️ Get match and workout statistics
• 🔒 Go premium to unlock score realtime updates
• 🧑‍🤝‍🧑 Play along with friends
• ✅ Have fun winning

Padel Time is available for free for iOS and watchOS devices and does provide a monthly or yearly subscription plan that enables you to share the excitment with your fellow players in realtime, enhancing the experience for everyone involved.

When your friends join your game by inserting your match session code, they will see the score update on their watch in realtime. A must-have feature for non-stop Padel competitions 🏆.

My mission is to showcase the work of iOS developers by providing a platform for them to share their articles and their side projects.

Every month, I will provide you with a list of high valuable resources as well as interesting apps submitted by the community. Everyone is welcome to submit articles or apps for free consideration. To submit content, users will be invited to log in, where they will have access to their dashboard.

I will review and evaluate each submission and decide what shall be published each month. I may opt to find another way to decide what will be published in the future. In the meantime, feel free to reach me out with suggestions!

My goal is to create a platform 100% fed by the iOS commmunity 💛.

Subscribe if you would like to stay up to date and receive emails when new content is published!