Snapp Technology
Hi folks,
In this week’s issue, we dive deep into high-performance Swift, from achieving Tflop/s speeds in LLM matrix multiplications to mastering the kinds of concise array sorting that make our code feel more elegant. We also tackle those subtle concurrency pitfalls, like unexpected main-thread hopping, that can quietly impact the responsiveness of our apps. Beyond the code, we explore the evolving landscape of developer tools with agent-native version control for AI-driven workflows and Xogot’s first-class native Mac experience for Godot. We’ve also included practical tips on maintaining a professional codebase using availability annotations to prune dead code, a comprehensive guide to streamlined persistence with SwiftData, and a comparison of how to manage concurrent tasks as we all strive for more structured concurrency. It’s a packed edition designed to help us make our apps faster, cleaner, and more robust.
Enjoy!
Articles
Swift
Sorting arrays in Swift using comparison operators as closures
This article explains how to make sorting arrays in Swift more concise and readable by using comparison operators as closures. By passing operators like < or > directly into the sorted(by:) method, we can write more expressive code. This technique leverages Swift’s functional programming capabilities to simplify collection management in our apps.
Unexpected Task suspension points in Swift Concurrency
Antoine van der Lee explores a subtle but impactful performance issue in Swift Concurrency where tasks unexpectedly start on the Main Actor, causing “main-thread hopping.” This happens when a Task inherits isolation from its surrounding context, even if the first operation is an await call to a different domain. By explicitly using @concurrent and MainActor.run, developers can avoid these unnecessary suspension points and improve the responsiveness of their apps.
What do you do when you want to get notified when a bunch of async tasks have finished?
Let’s compare the legacy DispatchGroup approach with the modern TaskGroup in Swift Concurrency for handling multiple parallel asynchronous tasks. This article demonstrates how TaskGroup simplifies code by replacing manual counter tracking (enter/leave) and callbacks with structured concurrency and async/await. This transition makes managing concurrent operations in our apps more intuitive and less prone to the errors associated with manual group management.
Deprecating your own convenience API
Majid explains a strategy for managing codebase cleanliness when supporting multiple iOS versions. By creating custom convenience wrappers for newer APIs and then using @available annotations with deprecated and obsoleted parameters, developers can leverage the compiler to identify and remove dead code once the minimum platform version is bumped. This approach helps in maintaining a professional codebase in our apps without accumulating unnecessary technical debt as the OS evolves.
AI / ML
Git for AI Agents: Version Control Built for LLM Coding Workflows
This entry explores the gap in traditional version control when using AI agents, where the “why” behind changes is often lost in ephemeral chat transcripts. It introduces the concept of agent-native version control, such as re_gent, which records reasoning, prompts, and plans alongside the diff. This approach allows developers to bisect decisions rather than just lines of code, greatly improving observability in agentic coding workflows.
Training an LLM in Swift, Part 1: Taking matrix multiplication from Gflop/s to Tflop/s
In this detailed exploration, Matt Gallagher takes a handwritten matrix multiplication implementation in Swift and optimizes it from a slow baseline to over 1 Tflop/s. He walks through various techniques, including using MutableSpan to avoid COW overhead, leveraging the Numerics library for fused-multiply-add, and employing InlineArray for stack allocation. The journey culminates in the use of Apple Silicon’s AMX unit and Metal GPU kernels, demonstrating that Swift can match or even exceed C’s performance for high-compute tasks in our apps.
Data
SwiftData Tutorial: Swift Data Storage for iOS Apps
This tutorial introduces SwiftData, Apple’s Swift-native persistence framework, highlighting its ability to replace the boilerplate of Core Data with a declarative @Model approach. The guide covers essential CRUD operations, advanced querying with predicates, and managing relational data, while providing a comparison with other storage options like SQLite and Realm. By integrating tightly with SwiftUI, SwiftData allows developers to focus on feature delivery rather than persistence plumbing in our apps.
Tools
Xogot on Mac
Xogot is bringing its SwiftUI-based shell for the Godot game engine to the Mac, aiming to provide a first-class native experience that follows Apple’s Human Interface Guidelines. By integrating features like a Report Navigator and a Command Palette, Xogot seeks to make Apple platform deployment and debugging more approachable for Godot developers, reducing the friction often associated with Xcode. This tool allows developers to focus on game creation while enjoying the professional feel of a native Mac creative application in our apps.