Mick F

Generating JWT Tokens in Swift for the App Store Connect API

2024-11-25T00:00:00+00:00

Using the App Store Connect API can significantly streamline workflows. For example, I use it to onboard new TestFlight testers for my apps much faster than through appstoreconnect.apple.com. While Apple provides a Generating Tokens for API Requests guide, this post shows how to create such tokens in Swift.

Generating JWT Tokens with JWTKit

The first step in using the API is to create JWT tokens. For this, I’ve used vapor/jwt-kit¹.

Step 1: Define the Payload

Start by defining the payload structure expected by Apple:

/// A JWT payload structure for App Store Connect APIs.
public struct AppStoreConnectPayload: JWTPayload {
    public let iss: IssuerClaim
    public let iat: IssuedAtClaim
    public let exp: ExpirationClaim
    public let aud: AudienceClaim
    public let scope: [String]?

    /// Creates a new payload for App Store Connect.
    public init(iss: String, iat: Date, exp: Date, aud: [String], scope: [String]? = nil) {
        self.iss = IssuerClaim(value: iss)
        self.iat = IssuedAtClaim(value: iat)
        self.exp = ExpirationClaim(value: exp)
        self.aud = AudienceClaim(value: aud)
        self.scope = scope
    }

    /// Verifies that the payload is valid and not expired.
    /// - Throws: An error if the payload is invalid or expired.
    public func verify(using _: some JWTAlgorithm) throws {
        try exp.verifyNotExpired()
    }
}

Step 2: Generate the Token

Once the payload is ready, create the token. Below is an example using sample data (based on Apple’s guide) and a dummy private key. Be sure to replace these with your actual values:

let pem = """
    -----BEGIN PRIVATE KEY-----
    MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgqIuh45D/4x9KGZ9v
    …
    uJcVQDj14FbV2QLpTbrNtk82W6ZMJT+FAZaJsx5Xiu9u83rbeICgZy3G
    -----END PRIVATE KEY-----
    """
let keys = JWTKeyCollection()
let kid = JWKIdentifier(string: "2X9R4HXF34")
let key = try ES256PrivateKey(pem: pem)
await keys.add(ecdsa: key, kid: kid)

let token = try await keys.sign(
    payload,
    kid: .init(string: keyIdentifier),
    header: ["typ": "JWT"]
)

You now have a JWT token! 🎉

Using the Code as a Dependency

If you prefer not to write your own implementation, you can use the dirtyhenry/swift-hoods package I created. It provides a jwtFactory dependency, compatible with pointfreeco/swift-dependencies.

Here’s how to integrate it:

@Dependency(\.jwtFactory) var jwtFactory

And in your application’s single entry-point:

let jwtFactory =  try LiveJWTFactory()
try await jwtFactory.addES256Key(pem: privateKey, keyIdentifier: keyIdentifier)

let newTransport = try withDependencies {
    $0.jwtFactory = jwtFactory
} operation: {
    return AppStoreConnectAPIAuthorizationTransport()
}

Additional Tips

Managing Secrets. Storing private keys and secrets securely is crucial. Check out the GenericPasswordKeychainItem class for handling keychain data on iOS and macOS.
Request Integration. To include the token with every API request, consider using a dedicated Transport. This makes it easy to compose behaviors around a URLSession instance.
Testing Tokens. Use the date dependency from pointfreeco/swift-dependencies to simulate different expiration scenarios when testing token verification².

With these steps, you can efficiently generate JWT tokens in Swift and streamline your use of the App Store Connect API. Happy coding!

One day, I would love to get rid of that dependency and use only CryptoKit to generate tokens. If you could help, let me know. ↩
Check out JWTFactoryTests in dirtyhenry/swift-hoods to see those tests. ↩

Slugify in Swift with applyingTransform

2024-07-03T00:00:00+00:00

I’ve recently added a function to my Blocks library that allows you to slugify any string.

What is a slug

A slug is the part of a URL that identifies a specific page on a website in a readable and concise way. For example, in the URL www.example.com/about-us, the slug is “about-us.”

Slugs have various other uses: you can use them to create file names in your file system, as Git branch names for issues you’re working on, and more.

What we need

Essentials. Slugs should only contain [a-z0-9-] characters ie no spaces, tabs, or underscores. Just letters, digits, and hyphens.

Accents removal. We want to remove accents from languages that use the Latin alphabet. This means characters like è, é, ê, ë, ě, ẽ, ē, ė, and ę should all be transformed to e.

Support for more alphabets. Strings written in alphabets other than Latin should be romanized as accurately as possible.

Basic emoji support. Emojis should be removed from the slug, except when the string consists solely of emojis.

We aim to achieve this without relying on external dependencies. Just Swift and Foundation.

The magic of `applyingTransform`

The StringProtocol protocol provides a powerful function called applyingTransform that performs most of these transformations. By applying a series of transformations, you can create an effective slugify function. The ones I used include:

.toLatin: Transliterates a string from any script to the Latin script;
.stripDiacritics: Removes diacritics from a string;
.stripCombiningMarks: Removes combining marks from a string;
.toUnicodeName: Converts characters to their Unicode names.

Examples

Here are some examples of what .slugify() does:

Hello Luka Dončić → hello-luka-doncic
😀 LOL → lol
😀 → grinning-face
🎸 → guitar
สวัสดีชาวโลก → swasdi-chaw-lok (Thai for “Hello World”)

The code

You can check out an up-to-date version of slugify on GitHub.

Here’s the current implementation:

public extension StringProtocol {
    func slugify() -> String {
        var slug = lowercased()

        slug = slug.applyingTransform(.toLatin, reverse: false) ?? slug
        slug = slug.applyingTransform(.stripDiacritics, reverse: false) ?? slug
        slug = slug.applyingTransform(.stripCombiningMarks, reverse: false) ?? slug
        slug = slug.replacingOccurrences(of: "[^a-z0-9]+", with: "-", options: .regularExpression)
        slug = slug.trimmingCharacters(in: CharacterSet(charactersIn: "-"))

        if !isEmpty, slug.isEmpty {
            if let extendedSelf = applyingTransform(.toUnicodeName, reverse: false)?
                .replacingOccurrences(of: "\\N", with: ""), self != extendedSelf {
                return extendedSelf.slugify()
            }
        }

        return slug
    }
}

Finding iOS simulators identifiers for CI

2024-03-29T00:00:00+00:00

GitHub Actions are powerful tools and a great complement to Xcode Cloud for Swift projects’ continuous integration.

However, I encountered an issue: when using xcodebuild test for iOS, a concrete device is required:

Cannot test target “FooTests” on “Any iOS Device”: Tests must be run on a concrete device

The challenge then arose: how to identify the simulator identifiers suitable for the intended device?

Of course, Apple provides a command for this:

xcrun simctl list devices available

But then CI requires parsing and filtering on this command’s output. Here are 3 solutions to do so.

Fastlane era

Fastlane provides a FastlaneCore::DeviceManager that greatly assists in inspecting available devices.

require 'fastlane_core/device_manager'

# Usage: latest_simulator_with_name('iPhone Xʀ').udid
def latest_simulator_with_name(device_name)
  result =
    FastlaneCore::DeviceManager.simulators
                               .select { |s| s.name == device_name }
                               .max_by { |s| Gem::Version.create(s.os_version) }
  return result unless result.nil?

  FastlaneCore::UI.error "#{device_name} missing. Please select one of the following:"
  FastlaneCore::DeviceManager.simulators
                             .each { |s| FastlaneCore::UI.message "#{s.name} (#{s.os_version})" }
  raise "Device with name #{device_name} cannot be found. Please install it."
end

Despite my extensive use of Fastlane, I’m starting to perceive a decline in its relevance with the emergence of Xcode Cloud.

Exploring the PointFreeCo Approach

As an admirer of the PointFreeCo team’s work, I investigated their methods and discovered a useful yet succinct shell command.

PLATFORM_IOS = iOS Simulator,id=$(call udid_for,iOS 17.2,iPhone \d\+ Pro [^M])

…

define udid_for
$(shell xcrun simctl list devices available '$(1)' | grep '$(2)' | sort -r | head -1 | awk -F '[()]' '{ print $$(NF-3) }')
endef

While efficient, it lacks readability.

Implementing a Swift Solution

To address this challenge, I developed a Swift script to obtain the necessary information. You can find the script on the Scripts section of my Blocks project or as a command of the CLI that I provide with this tool.

To use it in continuous integration (CI), follow these steps:

# Download the script and make it executable
curl -sSL https://raw.githubusercontent.com/dirtyhenry/swift-blocks/main/Scripts/ListDevices.swift \
  -o findDevice
chmod +x findDevice

# Find the device identifier
DEVICE_ID=$(./findDevice "$TEST_IOS_VERSION" "$TEST_IOS_SIMULATOR_MODEL")

# Run the test
set -o pipefail && xcodebuild test \
    -skipMacroValidation -skipPackagePluginValidation \
    -workspace foo.xcworkspace \
    -scheme "bar" \
    -destination platform="iOS Simulator,id=$DEVICE_ID" \
    | xcpretty

💡 I recommend setting TEST_IOS_VERSION and TEST_IOS_SIMULATOR_MODEL as environment variables so that failures after Xcode updates can be resolved without changing the code.

My Mission Statement as a Programmer

2024-01-06T00:00:00+00:00

tl;dr

As a programmer, I create eco-conscious software with user-friendly design, embracing IndieWeb principles. I’m cautious with big corporations, upholding ethics and user rights. My goal is to produce durable and sustainable code, prioritizing maintainability and developer well-being. I respond swiftly to evolving challenges for impactful work in a changing tech landscape.

A longer version

Let me explain. There is a sense of uneasiness with the state of the world these days. After having the privilege to spend a fun and peaceful holiday season, I wanted to do a headcheck on where I stand with my role as a programmer and if I am aligned with my aspirations and values. So I decided to write my mission statement. I will develop each of its components with an example of how I think I apply it.

🌍 Climate Friendliness

I need to consider all environmental impacts of the code I write: the hardware it runs on, the energy it requires, its purpose for the people running it.

Example. I work for Memo Bank, a bank for small and medium-sized companies, that prioritizes in a no bull-shit way the transition to a low carbon economy. It has been recognised as such by Reclaim Finance, and is one of the recommended banks on their website Change de banque.

🤝 Human Friendliness

I prioritise security and user experience, in that order, to promote the well-being of end-users. It involves creating software that is intuitive, inclusive, and positively impacts users’ lives.

Example. I feel that it was my main motivations to start running the Statium Newsletter, a minimalistic soccer newsletter written in French that focuses solely on the game. It filters out the noise from meaningless controversies, poor journalistic practices, invasive advertisement and poor user experience of alternative sources. As of today, statium.app has a perfect score of 100 in Performance, Accessibility, Best Practices and SEO with Lighthouse.

⚡ Mastery

I want to continuously get better at my craft. Software is never “done”. A skillset is never complete. I want to keep engaging on how to be a better programmer, a better team member, and a better person.

Example. I think a good practice of mastery is balancing being very curious with just what it needs of focus. I wrote about why side-projects are so important to me in the past: my curiosity is satisfied and the new things I learn have many positive impacts on my job at Memo Bank.

🌐 IndieWeb Friendliness

I support decentralised and people-focused technologies and products that help individuals to have greater control over their online presence and their data.

Example. I use RSS daily, I POSSE, I run a newsletter using Buttondown, my microblogging platform of choice is micro.blog, I favor community-run or independant sources when I use links in my blog posts (examples: TMDB, Discogs, Sports Reference, etc.). I make my default apps public.

🕵️‍♂️ Big Corporation Cautiousness

I am curious of the ethical considerations of big companies when engaging with their products and technologies. I avoid those that compromise user privacy or promote monopolistic behavior.

Example. I stopped using Gmail, I don’t actively use Meta products or X. I am wary of AI products and try to use them as sparingly and ethically as possible.

🌱 Durability & Sustainability

I focus on the longevity and sustainability of the software I write. I want my code to run for a long time, I want my mind and body to remain healthy for as long as possible, and I want my online presence to live long.

Example. I pick dependencies to rely on very carefully and sparingly, I express gratitude towards Open-Source developers, I avoid and fix dead-links, I maintain a good work-life balance.

Conclusion

This mission statement serves as a guiding compass in my journey as a programmer, reminding me of the values and principles I hold dear. It is a commitment to creating software that not only meets the needs of the present but also contributes positively to the future.

From block party to ’hood party

2023-12-24T00:00:00+00:00

Last year, I wrote about the joy sparked by side projects. This year, I wanted to write another small recap of what I have accomplished in 2023. I kept iterating on my projects but, more importantly, I kept consolidating the packages that I use to share code between projects: swift-blocks and swift-hoods. They are open-sourced and I wanted to formally introduce them to the world. Here we are.

🧱 Welcome to my blocks

For the last 2 years, I have been building swift-blocks, a dependency-free library of tools and patterns I use repeatedly on all my Swift projects.

It is not my first attempt to build such a library but it is the first time I feel really satisfied about its usefulness. What was different this time? Two factors:

For one, Swift Package Manager provides a much more convenient way to share code between projects than anything else in the past (Cocoapods, static libraries, etc.);
And then, I had a much better discipline to be consistent about using/iterating/adding things to the library over time.

Today, I released version 0.2.0 of the library. Here are the release notes. Help yourself.

🌐 Transport. Added a tinier version of objcio’s tiny-networking for concise endpoint description, combining URL requests and response parsing. Introduced URLRequestHeaderItem struct mimicking Foundation’s URLQueryItem.
📅 Calendar. Improved internal architecture and developer experience using result builders.
🔐 Security. Introduced support for PKCE and associated helpers.
🛟 Error Management. Introduced SimpleMessageError for convenient error handling, eliminating the need for forced unwrapping. Ideal for scenarios where a full error domain is not necessary.
🎨 SwiftUI. Introduced TaskStateButton interface components, for representing asynchronous task states. Supports four states: not started, running, completed (success), or failed.

The documentation for this package is now hosted on the Swift Package Index.

🏘️ Welcome to my ’hood

In 2023 though, I have been using The Composable Architecture a lot. And I built things that were depending on it. So in addition to swift-blocks, I started building another library, swift-hoods¹, which has a slightly bigger footprint in a project but is starting to turn out very useful as well.

Today, it is still in the early stages, but it already provides two useful items:

A keychain TCA dependency for easy testing of code that uses keychain items;
A processor for markdown files that include YAML front-matters.

I will detail how these work in the future.

🎄 Have a happy holiday and happy new year 🥂.

Hood standing for neighborhood… ie a larger version of a block. Get it? Kudos to my lovely wife for helping me find a good name. ↩

From the start, get rid of types you don’t control: a lesson (re)learned, Rolling Stones Edition

2023-11-09T00:00:00+00:00

In recent weeks, I’ve been reminded of a crucial lesson: “Do not use the objects that are used by an API¹ outside of the network layer of your application.”

While this might seem like common sense in a technical job interview, the real-world scenario brings its own challenges, especially when dealing with (a) an in-house designed API², (b) budget constraints, and (c) the task of writing boilerplate to convert DTO into model objects. It’s surprisingly easy to give in to the temptation.

I’m writing this post to emphasize that the effort is always worth it. To drive this point home, I’ll provide real-life examples to illustrate why.

Example 1: Future-proofing an API

Let’s delve into an API where a payload includes the name of a member of the Rolling Stones. And just for the heck of it, you decide to write an enum to represent this value. Because… why not?

Here’s the enum to kick things off:

/// 👅 Members of the Rolling Stones
enum RollingStone: String {
    case mick = "Mick Jagger"
    case keith = "Keith Richards"
    case bill = "Bill Wyman"
    case charlie = "Charlie Watts"
    case brian = "Brian Jones"
}

Now, imagine using a DTO as a model:

struct DTOAsModel: Codable {
    let rollingStone: RollingStone
}

extension RollingStone: Codable {}

And this works fine!

do {
    let member1 = try JSONDecoder().decode(
        DTOAsModel.self,
        from: """
        { "rollingStone": "Mick Jagger" }
        """.data(using: .utf8)!
    )
} catch {
    print(error)
}

But what if the backend adds “Mick Taylor” as a new possible value that your Swift code has no idea about?

do {
    let member2 = try JSONDecoder().decode(
        DTOAsModel.self,
        from: """
        { "rollingStone": "Mick Taylor" }
        """.data(using: .utf8)!
    )
} catch {
    print(error)
}

Oops, we crash.

There’s a quick and dirty way to fix this, and I’ll admit, I’ve been guilty of doing it. What if we changed rollingStone:

  struct DTOAsModel2: Codable {
-      let rollingStone: RollingStone
+      let rollingStone: String
  }

+ extension DTOAsModel {
+     var typedRollingStone: RollingStone? {
+         RollingStone(rawValue: rollingStone)
+     }
+ }

But then things get messy: objects are cluttered, autocompletion becomes hard to read, initializers are not using the enum type, etc.

So what I believe today is the right way to do things is:

Limit yourself to JSON-supported types in your DTO;
Create typed model-objects;
Add extensions that can convert from DTO objects into model objects in your network layer.

struct DTOAsJustDTO: Codable {
    let rollingStone: String
}

struct ProperModel {
    let rollingStone: RollingStone
}

extension ProperModel {
    init?(dto: DTOAsJustDTO) {
        guard let rollingStone = RollingStone(rawValue: dto.rollingStone) else {
            return nil
        }

        self.rollingStone = rollingStone
    }
}

At the cost of a little boilerplate, you have two clean objects that do things right.

There are many options to support future values of the enum:

A failable initializer, as in the example,
A throwing initializer,
A prop that can be optional,
Adding an .unknown rolling stone in the enum,

It is really up to you and what feels best.

Example 2: Improving testability of code you don’t control

Let’s take a look outside of the network layer, with other types of API that you don’t control. The principles are similar.

So now your app receives a push notification every time the Rolling Stones release an album.

func showNotification(_ notification: UNNotification) {
    let userInfo = notification.request.content.userInfo

    guard let albumName = userInfo["albumName"] as? String else {
        return
    }

    print(albumName)
}

How can you test this? You cannot create instances of UNNotification.

Instead, get rid of things out of your control early on. Take control of things. Like so:

enum NotificationEvent {
    case newAlbum(String)
}

extension NotificationEvent {
    init?(from notification: UNNotification) {
        guard let albumName = notification.request.content.userInfo["albumName"] as? String else {
            return nil
        }

        self = .newAlbum(albumName)
    }
}

func showNotification(_ notification: NotificationEvent) {
    guard case let NotificationEvent.newAlbum(albumName) = notification else {
        return
    }

    print(albumName)
}

With this code, testing NotificationEvent.init?(from:) will be challenging. But testing showNotification will be easy-peasy. Mission accomplished.

More examples to come?

For sure, I will encounter more examples in the future. And I’ll continue to update this post as a reference for my future-self on how I want to code future similar scenarios.

I will call them Data Transfer Objects aka DTO for the rest of this post ↩
So you sort of control it, right? Well, not really. If an API is designed for more than 1 client, it might include extra-details or complexity. So while you can think you control it as an organization, your Swift project does not. ↩

The Joy Sparked by Side Projects, 2022 Edition

2022-12-13T00:00:00+00:00

🎄 December is here! Like every year, it is time to watch Home Alone again and to review the progress I made as a developer over the past 12 months. Side projects contributed the most.

Why side projects are necessary for me

Yes, a paying job is your bread and butter. But having side projects is key to staying ahead of the younger guns of the tech world, flexing your developer muscles in new directions and anticipating what’s next for you at work.

Last year, I started writing a newsletter about soccer/football¹ for people based in France. The content is pretty basic. Still, I learned so much just setting it up, running it, and trying to automate as many steps as possible so that each edition would take as little time as possible to write, without compromising the quality of the content.

Things I learned

Here is a non-exhaustive list of the things I trained on last year to run the newsletter, in an approximative chronological order:

Swift Argument Parser. Writing a CLI in Swift is now my goto solution when I need to write scripts. Including at work. It is so much easier to write, document and maintain than Shell scripts.
Buttondown. This is an indie tool to bootstrap newsletters. As part of the side project journey, I believe it is worth exploring alternatives to big corporations so I skipped Mailchimp, Mailjet and similar options. While I really like Buttondown, I think the newsletter is now ready to grow out of it, and finding a better option for my needs is on the roadmap for 2023.
Linode. Similarly, I didn’t want to go the AWS route. And Linode’s interface is much clearer than AWS — though it is not as feature rich. Linode got recently bought by Akamai, so I am not as attached to it as I used to be.
Terraform. Infrastructure as code. I use it to create server instances, manage DNS for the domain names, create and manage buckets and keys.
iCalendar RFC. Not the sexiest subject. But I had to reverse-engineer how calendar software behaves to get the newsletter to work the way I wanted. Did you know that the iOS calendar behaves differently if you serve an ICS file with a 2XX HTTP status code than if you serve it via a 3XX? I did not.
JSONFeed. An alternative to RSS written in JSON.
Micro.blog. An alternative to Twitter. Duh.
Modern React web frameworks. I explored Next.js first, then Remix. Both are pretty amazing.
DocC. The new documentation framework by Apple. I used Jazzy before, but DocC — albeit sometimes awkward to use — is much more complete. As illustrated by Simon Støvring’s talk during FrenchKit 2022, you can create amazing documentation with it.
Xcode Cloud. First-party CI and automated distribution of apps. It seems to cover some common ground with Fastlane, very convenient to distribute the app I use to run the newsletter on my iPhone and iPad via TestFlight.
TabularData. A new framework provided by Apple to organize and explore data.
SwiftUI. I am sure you heard of it already 😉.
The Composable Architecture. A 3rd-party architecture library that solved all the problems that were holding me back when I first got my toes wet with SwiftUI.
OR-Tools library. Linear optimization library available in Python among others. Picking the right tools to do the right job is essential. I found this library to act like a Microsoft Excel solver.

Each of these tools would deserve their own post. I shouldn’t run out of inspiration for this blog next year.

The positive impacts on my paying job

🧰 A better set of tools I can use

Part of my job at Memo Bank is to write the iOS app that serves as the 2FA for critical operations. The app does not do much. But the things it does are critical. Our customers depend on it to pay salaries to their employees, pay taxes on time, and be safe with their transactions.

The app was bootstrapped with compatibility going up to iOS 12. Now that I got my hands dirty with SwiftUI and The Composable Architecture on my side projects, I feel comfortable adopting them in the app for upcoming features. That would not have been the case without the time I spent toying with them outside of work. I made many mistakes. I rewrote things multiple times. It is part of learning.

Could this time spent on my free time have been part of the job? Maybe. But I also like not having to be held accountable for anything when I explore and want to play around with new things. I do whatever I want, without having to justify my decisions to anyone else but me. I am in complete control of every decision. Freedom & Fun.

🤗 A greater empathy

“It should be easy, it is just a button.”

— Quite probably my past self, in a self-indulgent micro-agression towards some designer from my team. Who the hell did I think I was?

I wear every possible hat running this newsletter. I am a developer, a product manager, and a designer. I do customer support, manage the infrastructure, etc.

I get a glimpse of the struggles that every job comes with. I get reminded that good design is hard to get right, that keeping an infrastructure up takes effort, that making product decisions is hard. It is a useful humbling reminder that shit is hard to get right.

My tips and life lessons

🧱 Use a monorepo. Over time, I realized that using a monorepo for my projects was much more thrilling than having a million bunny projects with 5 commits each. The feeling of progress is much more satisfying.

🏎 Take shortcuts towards the fun. If you host your code on GitHub, don’t use an organization and don’t open-source what you are doing until you feel ready. For instance, at work, you should never leave secrets in your code. On a side project, why not? If stakes are low, leave the boring required things you write at work behind and sprint towards the fun parts.

⏱ How to find time for it? Any opportunity is good to take. My wife agreed to leave me off kids-duty on Thursday evenings. I try to write a little bit of code everyday, and when you work remotely, the lunch break is ideal for that. Over time, things build up and the output you get from a 5-minute slot grows.

Also, I recommend reading these tips from Antoine van der Lee. They are great to act as a guard rail against uncontrollable impulses to try this new thing. His point is to keep focus, realistic expectations and priorities straight.

Conclusion

Why are you still reading this? Go work on your side project!

I won’t discuss which term is best. I can’t put it better than Jason Kottke does: “it’s the sort of debate that 4th graders have on the playground”. ↩

Notes from FrenchKit 2022

2022-10-07T00:00:00+00:00

Previous editions: 2019 · 2018 · 2017

🌟 The talks I recommend

any Idea How to Use some Generics? — Antoine van der Lee

Dive into the difference between some vs any and how they can replace older forms of expressing constraints on generics.

Note the choice of case in the title. 🤣

— 📺 Watch

Building Custom Property Wrappers for SwiftUI (and how to test them) — Donny Wals

Implements a fetching data property wrapper for SwiftUI.

Donny is quite interesting because, year after year, he focuses on predicting what Apple plans for the future as opposed to investing in 3rd-party libraries or frameworks.

For instance, he seems genuinely convinced that, for Apple people, data fetchers belong to views — following Apple’s own APIs — and that Combine and Core Data are just as relevant in 2022 as they always were.

— 📺 Watch

Masterclass: Hacking iOS Apps - and trying to prevent it — Elliot Schrock

This talk provided a lot of valuable insights. Using a jailbroken iPhone, Elliot went backwards from the demo to the theory of hacking, highlighting how to control the app from the CLI. Elliot also mentioned this funny analogy about security:

🏃 🐻 If you’re being chased by a bear, you must run faster than the slowest guy.

Tools mentioned:

cycript (pronounced ssssscript apparently);
Hopper (disassembler);
Clutch (executable dumper);
ipainstaller.

Swift Quiz — Vincent Pradeilles

Three questions:

✅ Retaining cycles. I got this one right.
❌ Mutating function on a struct with a let property. You can reassign self. I got it wrong.
❌ Empty enums. Does the Swift compiler accept a function that has a signature that returns something but actually has an empty body, when the argument is an empty enum (which cannot be instantiated)? It does. I got it wrong too. But it explains why the signature of fatalError is Never.

— 📺 Watch

🔥 Hot Takes

I am so bad at socializing during conferences. My interactions with other human beings at FrenchKit consisted primarily of asking questions during Q&A sessions, but it was hard for me to go beyond that. I tried to attend an event on the Thursday evening. But a bar packed with 200 people, 95% of which are nerdy dorks like myself — now quite younger — is not an environment I can thrive in. I am taller and deafer than the average person so that would translate into me bending over groups of people, pretending I can hear what is being said. Not quite fun.

Next time, I will try to attend NSSpain. It was the last edition of FrenchKit per say. The hosts are willing to expand to other technologies — which will be appreciated after the dot conferences disappeared after being bought by Welcome to the Jungle.

I will build next features at work for iOS 14 users. Today, we support iOS 12. Looking at iosref’s iOS version by device table, I realized that bumping straight to iOS 14 will leave aside some devices stuck with iOS 12. But no device is stuck with iOS 13 — or iOS 14 for that matter. So, at the end of the day, iOS 14 sounds like a sweet spot to be able to benefit both from async/await and a decent version of SwiftUI.

I should give things a second chance. I’m talking about you jailbreaking phones — to put myself in hackers shoes — and UI testing.

🪣 The rest of my notes

Here I share raw notes from the other talks cause… why not?

Beyond Code: Skills for Impactful Development That Makes a Difference — Maxim Cramer

How to make impact beyond code? Mostly about communication. 🦒 The image of the giraffe in a park that every can sort of picture vs feature descriptions. We share very little of our knowledge when we communicate. Shocking fact: 2% of funding is for female founders.

— 📺 Watch

I 💕 Swift Concurrency — Tunde Adegoroye

Concurrency, async let, tasks and tasks groups, actors.

— 📺 Watch

How not to develop an “Umm” detector using Create ML — Yono Mittlefehldt

Um detector. Not really about code but about the thought process. Some tools mentioned worth bookmarking:

— 📺 Watch

Documenting your project with DocC — Simon Støvring

Wrap up around DocC by the author of the Runestone text editor.

I started using DocC with my Blocks project, but I didn’t know about tutorials with DocC.

— 📺 Watch

SwiftUI at Scale — Thomas Ricouard

The point was that SwiftUI is production ready. And apparently, it’s tied to the iOS version running the phone so it doesn’t make sense to use SwiftUI before iOS 14. I guess this means that SwiftUI in iOS 13 is broken.

— 📺 Watch

SwiftUI Navigation — Luis Ascorbe

Should we use SwiftUI or UIKit for navigation? It depends. He recommended the following:

NavigationStack.
Brandon Williams: SwiftUI Navigation & URL Routing.
Taking a look at The Composable Architecture aka TCA which sounds like a good idea.
Composable Architecture at Scale by Krzysztof Zablocki

— 📺 Watch

From source code to executable: a day in the life of a Build System — Samuel Giddinis

Why do we need build systems and the complexity behind them. Some notes:

Swiftlint has a Makefile;
Bazel is great for large monorepos but require a significant investment and care

GitHub - segiddins/Bazel-iOS-Workshop: AppBuilders 2022 workshop on building an iOS app with Bazel

— 📺 Watch

Migrating your legacy code to local SPM packages — Zouhair Mahieddine

This title describes exactly the content of the talk. 😆

— 📺 Watch

Testing for Accessibility — Robin Kanatzar

A reminder that the accessibility tool is good. Robin recommended the following tool:

Mobile Flow Analyzer - Evinced, Inc.

— 📺 Watch

Cloud Functions to the rescue — Zamzam Farzamipooya

The talk focuses on Firebase/Google. That’s kind of a non starter for my tastes.

It reminded me of stuff I did for Flâneur and why I didn’t like Firebase: data access boundaries are fragile and require significant effort.

— 📺 Watch

From App to Game Development — Michel-André Chirita

Interesting. The game is: Versus Arena

It made me want to develop a Backgammon game again.

— 📺 Watch

The journey of Widgets begins with one step — Audrey Sobgou-Zebaze

How to start implementing widgets with WidgetKit.

— 📺 Watch

Dealing With Dates With No Time in Swift

2022-03-02T00:00:00+00:00

Where the Streets Dates Have No Name Time

Where the Streets Have No Name, the U2 song, was released on 31 August 1987. At what time? It is not relevant. Just the date, ie the calendar day, matters. If I had to translate this in a JSON API, I would write the following: {"release_date": "1987-08-31"}, ie basic ISO 8601, no time or time zone.

When dealing with such dates with no time, some operations can be necessary. For instance, what is the 7th day after 31 August 1987? No dependency allowed. This blog post will answer this question. Easy peasy, right?

But beware, the experienced developer should be humble when coding such operations. Dealing with calendars is hard and I can easily prove it. Just answer this simple question: is every minute in a calendar 60 seconds long? If you answered “yes”, you failed the test. Go study and have fun.

Hopefully, Swift’s Foundation provides everything we need to avoid obvious traps. Let’s see what a struct to handle dates with no time could look like.

The implementation

This is the end result. A discussion follows.

import Foundation

/// A string that represents dates using their ISO 8601 representations.
///
/// `PlainDate` is a way to handle dates with no time — such as `2022-03-02` for March 2nd of 2022 — to
/// perform operations with convenience including adding days, dealing with ranges, etc.
///
/// ## Usage Overview
///
/// A plain date can be initiated from a string literal, and can be used to create ranges.
///
///     let plainDate: PlainDate = "2022-03-01"
///     let aWeekLater = plainDate.advanced(by: 7)
///     for day in march1st ..< aWeekLater {
///       print(day)
///     }
public struct PlainDate {
    // MARK: - Creating an instance

    /// Returns a date string initialized using their ISO 8601 representation.
    /// - Parameters:
    ///   - dateAsString: The ISO 8601 representation of the date. For instance, `2022-03-02`for March 2nd of 2022.
    ///   - calendar: The calendar — including the time zone — to use. The default is the current calendar.
    /// - Returns: A date string, or `nil` if a valid date could not be created from `dateAsString`.
    public init?(from dateAsString: String, calendar: Calendar = .current) {
        let formatter = Self.createFormatter(timeZone: calendar.timeZone)
        guard let date = formatter.date(from: dateAsString) else {
            return nil
        }

        self.init(date: date, calendar: calendar, formatter: formatter)
    }

    /// Returns a date string initialized using their ISO 8601 representation.
    /// - Parameters:
    ///   - date: The date to represent.
    ///   - calendar: The calendar — including the time zone — to use. The default is the current calendar.
    public init(date: Date, calendar: Calendar = .current) {
        self.init(date: date, calendar: calendar, formatter: Self.createFormatter(timeZone: calendar.timeZone))
    }

    private init(date: Date, calendar: Calendar = .current, formatter: ISO8601DateFormatter) {
        self.formatter = formatter
        self.date = date
        self.calendar = calendar
    }

    // MARK: - Properties

    private let formatter: ISO8601DateFormatter
    private let date: Date
    private let calendar: Calendar

    private static func createFormatter(timeZone: TimeZone) -> ISO8601DateFormatter {
        let formatter = ISO8601DateFormatter()
        formatter.formatOptions = [.withFullDate]
        formatter.timeZone = timeZone
        return formatter
    }
}

extension PlainDate: ExpressibleByStringLiteral {
    public init(stringLiteral value: String) {
        self.init(from: value)!
    }
}

extension PlainDate: Strideable {
    public func distance(to other: PlainDate) -> Int {
        let timeInterval = date.distance(to: other.date)
        return Int(round(timeInterval / 86400.0))
    }

    public func advanced(by value: Int) -> PlainDate {
        let newDate = calendar.date(byAdding: .day, value: value, to: date)!
        return PlainDate(date: newDate, calendar: calendar, formatter: formatter)
    }
}

Just how bad is DateString for a name?

Edit: the first name for this class was DateString. I know. Since, I found out about the Temporal proposal for JavaScript that introduces something very similar to what I am trying to achieve here as PlainDate. So I renamed this accordingly.

Why are time zones involved in this code?

It’s the result of logical decisions I made from the tools I had at hand:

Converting an ISO 8601 string? Use ISO8601DateFormatter!
What type does ISO8601DateFormatter convert the input String into? As a Date!
So I should use a Date — with time — to store a date with no time? Yes!
How can I output the date back into a String? Use ISO8601DateFormatter again!
But look at this test, it’s getting buggy around days on which clocks change to deal with daylight saving time? Use a time zone!
So I have to carry a Calendar and a TimeZone around? No need: a Calendar does include a TimeZone, just carry the Calendar around!

Implementing ExpressibleByStringLiteral is so easy and convenient!

Yes, it is. Expressing a PlainDate just as "1987-08-31" is indeed pretty awesome.

Wow, and what about implementing Strideable?

I know, right? On top of answering our original question (date.advanced(by: offset)), Strideable helps doing things like:

let startDate: PlainDate = "2022-03-01"
let aWeekLater = startDate.advanced(by: 7)
for date in  startDate ..< aWeekLater {
  // do something.
}

Wait a minute! Is this a hard-coded 86400 in the code? Isn’t that forbidden?

🕵️ Good eye. 86400 is the number of seconds in a typical day. But not all days are 86400 seconds long. But the point here is to compute the distance in days between two dates, and I think this implementation is OK. I’ll explain why:

Calendar is ignoring leap seconds. I know because a former Apple Foundation employee told me so.
See the round? This is enough to deal with daylight savings according to my tests and my understanding of how daylight savings work. Consider a collection that contains the number of seconds of an arbitrary number of consecutive days. (a) There’s more than a 99% chance that a randomly picked item is 86400. (b) Considering that the 2 possible outliers values will alternate: if you find a 23-hour long day (82800 seconds) in the collection, you will find a 25-hour long day (90000 seconds) before you find another occurrence of a 23-hour long day. So the average of a set will tend to 86400 as it gets bigger.
Here is a more intellectually satisfying alternative for this computation. It might be more solid if you’re working on something really time-sensitive. But it is about 2 times slower. So as long as my fast implementation does not fail me, I’ll stick to it.

let start = calendar.ordinality(of: .day, in: .era, for: self.date)
let end = calendar.ordinality(of: .day, in: .era, for: other.date)

guard let start = start, let end = end else {
    fatalError("The distance between 2 dates could not be computed.")
}

return end - start

Conclusion

Mission accomplished. Feel free to use this PlainDate class as is. I’ve been using it for a hobby project — a soccer newsletter — and it works great. If you can read French and soccer is your thing, you can sign up for the newsletter.

Addendum — iOS & macOS Time Zones

Here is a table of all the known time zones’ identifiers and abbreviations as run on iOS 15.2 and macOS 12.2.1.

For some reason, UTC is an abbreviation to the UTC identifier, but UTC is missing in the list of known identifiers. 🤷‍♂️ I initalized a time zone using UTC: it succeeded and querying the identifier returned GMT. Double-🤷‍♂️.

Identifier	Abbreviations
Africa/Abidjan
Africa/Accra
Africa/Addis_Ababa	EAT
Africa/Algiers
Africa/Asmara
Africa/Bamako
Africa/Bangui
Africa/Banjul
Africa/Bissau
Africa/Blantyre
Africa/Brazzaville
Africa/Bujumbura
Africa/Cairo
Africa/Casablanca
Africa/Ceuta
Africa/Conakry
Africa/Dakar
Africa/Dar_es_Salaam
Africa/Djibouti
Africa/Douala
Africa/El_Aaiun
Africa/Freetown
Africa/Gaborone
Africa/Harare	CAT
Africa/Johannesburg
Africa/Juba
Africa/Kampala
Africa/Khartoum
Africa/Kigali
Africa/Kinshasa
Africa/Lagos	WAT
Africa/Libreville
Africa/Lome
Africa/Luanda
Africa/Lubumbashi
Africa/Lusaka
Africa/Malabo
Africa/Maputo
Africa/Maseru
Africa/Mbabane
Africa/Mogadishu
Africa/Monrovia
Africa/Nairobi
Africa/Ndjamena
Africa/Niamey
Africa/Nouakchott
Africa/Ouagadougou
Africa/Porto-Novo
Africa/Sao_Tome
Africa/Tripoli
Africa/Tunis
Africa/Windhoek
America/Adak
America/Anchorage
America/Anguilla
America/Antigua
America/Araguaina
America/Argentina/Buenos_Aires	ART
America/Argentina/Catamarca
America/Argentina/Cordoba
America/Argentina/Jujuy
America/Argentina/La_Rioja
America/Argentina/Mendoza
America/Argentina/Rio_Gallegos
America/Argentina/Salta
America/Argentina/San_Juan
America/Argentina/San_Luis
America/Argentina/Tucuman
America/Argentina/Ushuaia
America/Aruba
America/Asuncion
America/Atikokan
America/Bahia
America/Bahia_Banderas
America/Barbados
America/Belem
America/Belize
America/Blanc-Sablon
America/Boa_Vista
America/Bogota	COT
America/Boise
America/Cambridge_Bay
America/Campo_Grande
America/Cancun
America/Caracas
America/Cayenne
America/Cayman
America/Chicago	CDT, CST
America/Chihuahua
America/Costa_Rica
America/Creston
America/Cuiaba
America/Curacao
America/Danmarkshavn
America/Dawson
America/Dawson_Creek
America/Denver	MDT
America/Detroit
America/Dominica
America/Edmonton
America/Eirunepe
America/El_Salvador
America/Fort_Nelson
America/Fortaleza
America/Glace_Bay
America/Godthab
America/Goose_Bay
America/Grand_Turk
America/Grenada
America/Guadeloupe
America/Guatemala
America/Guayaquil
America/Guyana
America/Halifax	ADT, AST
America/Havana
America/Hermosillo
America/Indiana/Indianapolis
America/Indiana/Knox
America/Indiana/Marengo
America/Indiana/Petersburg
America/Indiana/Tell_City
America/Indiana/Vevay
America/Indiana/Vincennes
America/Indiana/Winamac
America/Inuvik
America/Iqaluit
America/Jamaica
America/Juneau	AKDT, AKST
America/Kentucky/Louisville
America/Kentucky/Monticello
America/Kralendijk
America/La_Paz
America/Lima	PET
America/Los_Angeles	PDT, PST
America/Lower_Princes
America/Maceio
America/Managua
America/Manaus
America/Marigot
America/Martinique
America/Matamoros
America/Mazatlan
America/Menominee
America/Merida
America/Metlakatla
America/Mexico_City
America/Miquelon
America/Moncton
America/Monterrey
America/Montevideo
America/Montreal
America/Montserrat
America/Nassau
America/New_York	EDT, EST
America/Nipigon
America/Nome
America/Noronha
America/North_Dakota/Beulah
America/North_Dakota/Center
America/North_Dakota/New_Salem
America/Nuuk
America/Ojinaga
America/Panama
America/Pangnirtung
America/Paramaribo
America/Phoenix	MST
America/Port-au-Prince
America/Port_of_Spain
America/Porto_Velho
America/Puerto_Rico
America/Punta_Arenas
America/Rainy_River
America/Rankin_Inlet
America/Recife
America/Regina
America/Resolute
America/Rio_Branco
America/Santa_Isabel
America/Santarem
America/Santiago	CLST, CLT
America/Santo_Domingo
America/Sao_Paulo	BRST, BRT
America/Scoresbysund
America/Shiprock
America/Sitka
America/St_Barthelemy
America/St_Johns	NDT, NST
America/St_Kitts
America/St_Lucia
America/St_Thomas
America/St_Vincent
America/Swift_Current
America/Tegucigalpa
America/Thule
America/Thunder_Bay
America/Tijuana
America/Toronto
America/Tortola
America/Vancouver
America/Whitehorse
America/Winnipeg
America/Yakutat
America/Yellowknife
Antarctica/Casey
Antarctica/Davis
Antarctica/DumontDUrville
Antarctica/Macquarie
Antarctica/Mawson
Antarctica/McMurdo
Antarctica/Palmer
Antarctica/Rothera
Antarctica/South_Pole
Antarctica/Syowa
Antarctica/Troll
Antarctica/Vostok
Arctic/Longyearbyen
Asia/Aden
Asia/Almaty
Asia/Amman
Asia/Anadyr
Asia/Aqtau
Asia/Aqtobe
Asia/Ashgabat
Asia/Atyrau
Asia/Baghdad
Asia/Bahrain
Asia/Baku
Asia/Bangkok	ICT
Asia/Barnaul
Asia/Beirut
Asia/Bishkek
Asia/Brunei
Asia/Calcutta
Asia/Chita
Asia/Choibalsan
Asia/Chongqing
Asia/Colombo
Asia/Damascus
Asia/Dhaka	BDT
Asia/Dili
Asia/Dubai	GST
Asia/Dushanbe
Asia/Famagusta
Asia/Gaza
Asia/Harbin
Asia/Hebron
Asia/Ho_Chi_Minh
Asia/Hong_Kong	HKT
Asia/Hovd
Asia/Irkutsk
Asia/Jakarta	WIT
Asia/Jayapura
Asia/Jerusalem
Asia/Kabul
Asia/Kamchatka
Asia/Karachi	PKT
Asia/Kashgar
Asia/Kathmandu
Asia/Katmandu
Asia/Khandyga
Asia/Krasnoyarsk
Asia/Kuala_Lumpur
Asia/Kuching
Asia/Kuwait
Asia/Macau
Asia/Magadan
Asia/Makassar
Asia/Manila	PHT
Asia/Muscat
Asia/Nicosia
Asia/Novokuznetsk
Asia/Novosibirsk
Asia/Omsk
Asia/Oral
Asia/Phnom_Penh
Asia/Pontianak
Asia/Pyongyang
Asia/Qatar
Asia/Qostanay
Asia/Qyzylorda
Asia/Rangoon
Asia/Riyadh
Asia/Sakhalin
Asia/Samarkand
Asia/Seoul	KST
Asia/Shanghai
Asia/Singapore	SGT
Asia/Srednekolymsk
Asia/Taipei
Asia/Tashkent
Asia/Tbilisi
Asia/Tehran	IRST
Asia/Thimphu
Asia/Tokyo	JST
Asia/Tomsk
Asia/Ulaanbaatar
Asia/Urumqi
Asia/Ust-Nera
Asia/Vientiane
Asia/Vladivostok
Asia/Yakutsk
Asia/Yangon
Asia/Yekaterinburg
Asia/Yerevan
Atlantic/Azores
Atlantic/Bermuda
Atlantic/Canary
Atlantic/Cape_Verde
Atlantic/Faroe
Atlantic/Madeira
Atlantic/Reykjavik
Atlantic/South_Georgia
Atlantic/St_Helena
Atlantic/Stanley
Australia/Adelaide
Australia/Brisbane
Australia/Broken_Hill
Australia/Currie
Australia/Darwin
Australia/Eucla
Australia/Hobart
Australia/Lindeman
Australia/Lord_Howe
Australia/Melbourne
Australia/Perth
Australia/Sydney
Europe/Amsterdam
Europe/Andorra
Europe/Astrakhan
Europe/Athens	EEST, EET
Europe/Belgrade
Europe/Berlin
Europe/Bratislava
Europe/Brussels
Europe/Bucharest
Europe/Budapest
Europe/Busingen
Europe/Chisinau
Europe/Copenhagen
Europe/Dublin
Europe/Gibraltar
Europe/Guernsey
Europe/Helsinki
Europe/Isle_of_Man
Europe/Istanbul	TRT
Europe/Jersey
Europe/Kaliningrad
Europe/Kiev
Europe/Kirov
Europe/Lisbon	WEST, WET
Europe/Ljubljana
Europe/London	BST
Europe/Luxembourg
Europe/Madrid
Europe/Malta
Europe/Mariehamn
Europe/Minsk
Europe/Monaco
Europe/Moscow	MSD, MSK
Europe/Oslo
Europe/Paris	CEST, CET
Europe/Podgorica
Europe/Prague
Europe/Riga
Europe/Rome
Europe/Samara
Europe/San_Marino
Europe/Sarajevo
Europe/Saratov
Europe/Simferopol
Europe/Skopje
Europe/Sofia
Europe/Stockholm
Europe/Tallinn
Europe/Tirane
Europe/Ulyanovsk
Europe/Uzhgorod
Europe/Vaduz
Europe/Vatican
Europe/Vienna
Europe/Vilnius
Europe/Volgograd
Europe/Warsaw
Europe/Zagreb
Europe/Zaporozhye
Europe/Zurich
GMT	GMT
Indian/Antananarivo
Indian/Chagos
Indian/Christmas
Indian/Cocos
Indian/Comoro
Indian/Kerguelen
Indian/Mahe
Indian/Maldives
Indian/Mauritius
Indian/Mayotte
Indian/Reunion
Pacific/Apia
Pacific/Auckland	NZDT, NZST
Pacific/Bougainville
Pacific/Chatham
Pacific/Chuuk
Pacific/Easter
Pacific/Efate
Pacific/Enderbury
Pacific/Fakaofo
Pacific/Fiji
Pacific/Funafuti
Pacific/Galapagos
Pacific/Gambier
Pacific/Guadalcanal
Pacific/Guam
Pacific/Honolulu	HST
Pacific/Johnston
Pacific/Kanton
Pacific/Kiritimati
Pacific/Kosrae
Pacific/Kwajalein
Pacific/Majuro
Pacific/Marquesas
Pacific/Midway
Pacific/Nauru
Pacific/Niue
Pacific/Norfolk
Pacific/Noumea
Pacific/Pago_Pago
Pacific/Palau
Pacific/Pitcairn
Pacific/Pohnpei
Pacific/Ponape
Pacific/Port_Moresby
Pacific/Rarotonga
Pacific/Saipan
Pacific/Tahiti
Pacific/Tarawa
Pacific/Tongatapu
Pacific/Truk
Pacific/Wake
Pacific/Wallis

The code to output this table:

import Foundation

for identifier in TimeZone.knownTimeZoneIdentifiers.sorted() {
    let abbreviations = TimeZone.abbreviationDictionary.filter { (k, v) in
        v == identifier
    }
    print("| \(identifier) | \(abbreviations.keys.sorted().joined(separator: ", ")) |")
}

A Swift Recoverable Precondition That Can Throw

2021-12-17T00:00:00+00:00

What on Earth is a recoverable precondition? Isn’t the point of a precondition to be non-recoverable?

Yes. Sorry I couldn’t think of a better name¹.

The Result

/// Checks a necessary condition for making forward progress.
///
/// The difference with `precondition` is that if an error is _thrown_ when the condition is executed, the error will
/// be _rethrown_ so that it can be recovered. But this recoverability does not apply if the condition executes
/// properly and its condition fails.
///
/// In other words, this function is a wrapper around `precondition` so that it can be fed a condition closure that can
/// throw.
func recoverablePrecondition(
    _ condition: @autoclosure () throws -> Bool,
    _ message: @autoclosure () -> String = String(),
    file: StaticString = #file,
    line: UInt = #line
) rethrows {
    if !(try condition()) {
        preconditionFailure(message(), file: file, line: line)
    }
}

What is this?

Let me explain. Here is the code I had:

precondition(aLittleTenderness())

But then, I had to make aLittleTenderness able to throw, and precondition was yelling at me about it:

Property access can throw, but it is not marked with 'try' and it is executed in
a non-throwing autoclosure

Even when I tried a little tenderness²:

precondition(try aLittleTenderness())

The compiler would complain:

Property access can throw, but it is executed in a non-throwing autoclosure

And this alternative looked terrible:

precondition((try? aLittleTenderness()) ?? false)

So I created a recoverable precondition, which means:

if the code throws, then try to recover from it;
if the code does not throw, treat it as a precondition.

Don’t hate me. Listen to soul music instead.

Lessons Learned

Look at this badass signature! Of course I started from the signature of precondition and I adapted it to my needs. It features some keywords I don’t use everyday. Each keyword deserves its own extensive explanation. But wait, other people have already written about them:

If you can think of one, let me know. ↩
Beware, a terrible music joke is hiding in this statement, can you spot it? ↩

Mick F

Generating JWT Tokens in Swift for the App Store Connect API

Generating JWT Tokens with JWTKit

Step 1: Define the Payload

Step 2: Generate the Token

Using the Code as a Dependency

Additional Tips

Slugify in Swift with applyingTransform

What is a slug

What we need

The magic of applyingTransform

Examples

The code

Finding iOS simulators identifiers for CI

Fastlane era

Exploring the PointFreeCo Approach

Implementing a Swift Solution

My Mission Statement as a Programmer

tl;dr

A longer version

🌍 Climate Friendliness

🤝 Human Friendliness

⚡ Mastery

🌐 IndieWeb Friendliness

🕵️‍♂️ Big Corporation Cautiousness

🌱 Durability & Sustainability

Conclusion

From block party to ’hood party

🧱 Welcome to my blocks

🏘️ Welcome to my ’hood

From the start, get rid of types you don’t control: a lesson (re)learned, Rolling Stones Edition

Example 1: Future-proofing an API

Example 2: Improving testability of code you don’t control

More examples to come?

The Joy Sparked by Side Projects, 2022 Edition

Why side projects are necessary for me

Things I learned

The positive impacts on my paying job

🧰 A better set of tools I can use

🤗 A greater empathy

My tips and life lessons

Conclusion

Notes from FrenchKit 2022

🌟 The talks I recommend

any Idea How to Use some Generics? — Antoine van der Lee

Building Custom Property Wrappers for SwiftUI (and how to test them) — Donny Wals

Masterclass: Hacking iOS Apps - and trying to prevent it — Elliot Schrock

Swift Quiz — Vincent Pradeilles

🔥 Hot Takes

🪣 The rest of my notes

Beyond Code: Skills for Impactful Development That Makes a Difference — Maxim Cramer

I 💕 Swift Concurrency — Tunde Adegoroye

How not to develop an “Umm” detector using Create ML — Yono Mittlefehldt

Documenting your project with DocC — Simon Støvring

SwiftUI at Scale — Thomas Ricouard

SwiftUI Navigation — Luis Ascorbe

From source code to executable: a day in the life of a Build System — Samuel Giddinis

Migrating your legacy code to local SPM packages — Zouhair Mahieddine

Testing for Accessibility — Robin Kanatzar

Cloud Functions to the rescue — Zamzam Farzamipooya

From App to Game Development — Michel-André Chirita

The journey of Widgets begins with one step — Audrey Sobgou-Zebaze

Dealing With Dates With No Time in Swift

Where the Streets Dates Have No Name Time

The implementation

Just how bad is DateString for a name?

Why are time zones involved in this code?

Implementing ExpressibleByStringLiteral is so easy and convenient!

Wow, and what about implementing Strideable?

Wait a minute! Is this a hard-coded 86400 in the code? Isn’t that forbidden?

Conclusion

Addendum — iOS & macOS Time Zones

A Swift Recoverable Precondition That Can Throw

The Result

What is this?

Lessons Learned

The magic of `applyingTransform`