Stanford CS193p: iOS Development with SwiftUI | 2025 | L13: SwiftData

Key Concepts

• SwiftData: Apple’s new framework for simplifying data persistence in Swift applications, built on top of a SQL database.
• @Model Macro: Marks classes for persistence, automatically making them @Observable.
• Data Type Restrictions: @Model classes are limited to primitive types, Data, other @Model classes (relationships), and Codable types.
• Relationships & Deletion Rules: Connections between @Model classes, managed with @Relationship and deleteRule attributes.
• Trade-offs in Persistence: Balancing simplicity (using Codable) with functionality (querying and searching).
• UI Independence: Designing models to be agnostic to the user interface for greater flexibility.
• AI-Assisted Development: Utilizing tools like ChatGPT to generate code and accelerate development.

SwiftData: From Introduction to Model Adaptation

Initial Overview & Core Principles

SwiftData is Apple’s new framework designed to simplify data persistence in Swift applications. It abstracts the complexities of interacting with an underlying SQL database, allowing developers to work directly with Swift structures, closures, and macros. The primary goal is to enable data to persist across app launches and device restarts. The core mechanism for marking a class as persistent is the @Model macro. Applying @Model automatically makes the class @Observable, eliminating the need to declare both. Only classes can be marked with @Model; structs must be converted to classes for persistence.

Data types within @Model classes are restricted to primitive types (numbers, strings, booleans, dates), Data (a bit buffer), other @Model classes (creating relationships), and types conforming to the Codable protocol. Relationships between tables are created using variables of type @Model, and the delete rule attribute (e.g., .cascade) controls cascading deletes. Codable allows storing arbitrary data structures as a "blob," but limits searchability to equality checks. Arrays of @Model types are supported but are unordered, requiring manual management of order. Computed properties can be used to transform unsupported data types or enforce ordering. Schema attributes like @Attribute(.unique) and @Attribute(.externalStorage) provide metadata for the database schema, while @Attribute(.transient) prevents storage.

Adapting the Codebreaker Model

The lecture series demonstrates these concepts by adapting the Codebreaker game project to use SwiftData. Initial efforts focused on converting the existing model to utilize @Model. However, challenges arose when attempting to persist the Kind enum, which contains associated data within the Match enum. Directly making the Kind enum Codable failed because Swift could not automatically synthesize conformance due to the associated data.

Two approaches were considered: storing Kind as a Codable data blob or representing it as a primitive string type. The latter was chosen to enable querying based on Kind properties. By representing Kind as a string, the model gains the ability to search for games with specific match types (e.g., all pegs inexact). To maintain code compatibility, a computed property (_kind) was introduced to bridge the gap between existing code expecting a Kind enum and the new string representation.

Leveraging AI & Enum Raw Values

AI assistance, specifically ChatGPT, was used to generate code for converting between the Kind enum and its string representation, including encoding and decoding functions. Further refinement involved utilizing raw values in the Match enum (Match: String), which automatically provides a string representation and a failable initializer for creating enums from strings.

The overarching goal is to create a UI-independent model. Representing pegs as strings allows the model to support different UI representations (emojis, colors, words) without requiring changes to the core data logic. Throughout the adaptation process, errors related to uninitialized properties and type mismatches within the SwiftData framework were addressed. A dedicated extension to the CodeBreaker model was created to handle UI-specific logic, such as color conversions, ensuring the core model remains UI-agnostic.

Key Considerations & Trade-offs

The process highlighted several key considerations. Choosing a string representation for Kind involved a trade-off between simplicity (using Codable) and functionality (querying). Maintaining a UI-independent model is crucial for flexibility and future extensibility. The use of AI tools like ChatGPT demonstrated their potential to accelerate development by generating boilerplate code. Computed properties proved to be a powerful mechanism for abstracting implementation details and maintaining code compatibility.

Conclusion

SwiftData offers a simplified approach to data persistence in Swift, abstracting the complexities of SQL databases. Successfully integrating SwiftData requires careful consideration of data type restrictions, relationships, and the trade-offs between simplicity and functionality. The adaptation of the Codebreaker model demonstrates the practical application of these concepts, emphasizing the importance of UI independence, leveraging AI tools, and utilizing computed properties for abstraction. The next steps involve exploring fetching, sorting, and searching data within the SwiftData framework.