NickAtGit

A Long-Time Apple Customer Asking for the Company I Once Loved

To the people inside Apple,

I'm writing this not as a complaint about a product, but as someone who has loved this company for years — and who is now struggling to reconcile that love with what I'm seeing.

I know that most of you who work at Apple didn't sign up for politics. You signed up to build beautiful things, to make technology that empowers people, to be part of something that "thinks different." Many of you probably share my values. Many of you are probably as uncomfortable as I am.

But I need you to know what it looks like from out here.

NickAtGit

In iOS 17, SwiftUI introduces the @Observable macro and the @Bindable property wrapper, enhancing state management and data binding capabilities. These tools streamline the development process by reducing boilerplate code and improving performance. This article explores the functionalities of @Observable and @Bindable, compares them with @ObservedObject, and provides guidance on their appropriate usage.

Understanding @Observable

The @Observable macro simplifies the creation of observable objects by automatically synthesizing conformance to the Observable protocol for classes. This approach reduces the need for manual implementation of the ObservableObject protocol and the @Published property wrapper.

Key Features of @Observable:

• Automatic Conformance: Automatically makes all properties of a class observable without explicit annotations.
• Class Support: Designed exclusively for classes; structs are not supported.

NickAtGit

What is an EnvironmentObject in SwiftUI?

An EnvironmentObject is a property wrapper in SwiftUI that allows shared data to be injected into a view hierarchy. It provides a way to pass data to multiple views in a tree without manually passing it through initializers.

Key Features:

1. Global in Scope: Once provided, it is accessible to all child views within the hierarchy.
2. Observable: The object must conform to the ObservableObject protocol, and views using it automatically update when the data changes.
3. Dependency Injection: It is injected into the environment using .environmentObject(_:).

Example:

NickAtGit

Mastering Swift Concurrency in Swift 6

Swift 6 brings exciting advancements to concurrency, building on the strong foundation laid by Swift 5.5. Whether you're building a networking-heavy app, managing complex task flows, or optimizing shared state, Swift concurrency offers a modern, structured, and safe way to manage asynchronous work. In this post, we'll explore the fundamentals and new refinements in Swift 6 that make concurrency both powerful and approachable.

---

What Is Swift Concurrency?

Swift Concurrency is a set of language features designed to handle asynchronous programming. It includes async/await, tasks, actors, and structured concurrency to simplify code execution across multiple threads without the risks of race conditions or deadlocks.

NickAtGit

Understanding async/await and Threading in SwiftUI: Do API Calls Need to Be on a Background Thread?

Swift’s async/await model has revolutionized asynchronous programming, making it cleaner and more intuitive. However, when working with SwiftUI, developers often wonder:

Do API calls in SwiftUI using async/await need to be explicitly dispatched to a background thread?

The short answer: No—and here’s why.

---