SwiftUI Property Wrappers Explained Through a Real Feed App

In this video, we’ll walk through and explain the networking service code.

You’ll learn how the service handles asynchronous data fetching using async/await, implements retry logic with exponential backoff, and uses custom error handling to manage failed requests. We’ll also cover how to validate HTTP responses, why certain status codes should not be retried, and how this service fits cleanly into the MVVM architecture through protocol-based dependency injection. This is a practical, real-world example of writing maintainable, testable network code in a SwiftUI app.

In this section, you’ll learn how to build a robust networking service in Swift using modern asynchronous programming techniques. You'll implement a reusable component that handles HTTP requests with built-in retry logic and exponential backoff. We'll cover how to validate HTTP responses, handle network failures gracefully, and design your service for testability and clean integration within the MVVM architecture. By the end, you'll understand how to isolate and manage networking concerns effectively in any SwiftUI app.

You’ll learn how the service takes raw RSS and Atom feed data and converts it into structured Article models using the FeedKit library. We’ll cover how to safely extract and validate required fields, handle optional data gracefully, and ensure the resulting data is clean and usable by the view model. This section demonstrates how to isolate parsing logic in a dedicated service, keeping your app modular, readable, and aligned with the MVVM architecture.

In this lecture, you'll learn how to build a FeedParser service that processes raw RSS and Atom feed data into structured Swift model objects. Using the FeedKit library, you'll implement a parser that supports multiple feed formats and safely extracts titles, links, and publication dates for display in your app. We'll focus on clean error handling, extensibility, and separation of concerns, ensuring your parser integrates seamlessly into the MVVM architecture. By the end of this section, you'll have a reusable and reliable parsing layer that transforms unstructured data into meaningful content for your UI.

You’ll see how the view model serves as the bridge between the view and the underlying data layers, managing state with @Published properties and coordinating network and parsing logic. We’ll cover how it uses dependency injection to remain decoupled and testable, how it handles asynchronous data fetching safely on the main thread with @MainActor, and how it updates the view reactively. This walkthrough will solidify your understanding of how to implement the MVVM pattern effectively in a real SwiftUI app.

The @MainActor attribute in Swift is used to indicate that all code within a class, struct, or function must be executed on the main thread. This is particularly important in iOS development because any updates to the UI or @Publishedproperties must happen on the main thread to avoid race conditions, crashes, or unexpected behavior.

In this lecture, you’ll learn how ObservableObject enables SwiftUI views to react to changes in a ViewModel’s state. By conforming to this protocol and using the @Published property wrapper, your ViewModel can automatically notify the view layer when its data changes. This allows for a clean, reactive UI that stays in sync with the underlying model, all without manual refresh logic. We'll explore how ObservableObject fits into the MVVM pattern and how it powers data-driven interfaces in SwiftUI applications.

In this lecture, you'll explore the role of the @Published property wrapper in SwiftUI and how it enables automatic UI updates in response to data changes. You'll learn how to declare and use @Published within an ObservableObject to build reactive and dynamic user interfaces. We’ll cover how it integrates with the MVVM pattern and simplifies the process of keeping the UI in sync with your app’s state. By the end of this section, you’ll understand how @Publishedhelps drive SwiftUI’s declarative, data-driven approach to app development.

You’ll learn how the SwiftUI view observes the view model using @ObservedObject, responds to state changes with @State, and conditionally renders UI based on loading and error states. We’ll explore how the view binds to user input through the Picker, displays article data in a dynamic list, and uses SwiftUI’s .task modifier to trigger async loading. This section ties together all layers of the MVVM structure, showing how the UI reacts to real-time updates in a clean, declarative way.

In this video, you’ll learn how to set the initial value of a @State property inside a custom initializer.

We’ll cover why you can’t assign directly to the wrapped value in SwiftUI and show how to correctly use the underscore (_) to access the property wrapper and initialize state using State(initialValue:). This is a clean and powerful technique that avoids unnecessary workarounds and helps you maintain SwiftUI's expected behavior while keeping your code concise and idiomatic.

In this lecture, you’ll learn how the @State property wrapper enables SwiftUI views to manage their own local, dynamic state. We'll explore how @State stores and persists values across view updates, and how changes to these values automatically trigger view re-rendering. You’ll see practical examples of using @State to control UI elements such as loading indicators, local selections, and view-specific data. By the end of this section, you’ll understand how @State fits into SwiftUI’s reactive framework and when it’s appropriate to use it.

In this lecture, you'll learn the difference between @StateObject and @ObservedObject, two essential property wrappers used to manage and observe ObservableObject instances in SwiftUI. We'll cover when to use each one based on ownership: @StateObject for views that create and manage their own state, and @ObservedObject for views that observe external state passed in from elsewhere. Through practical examples, you'll understand how to maintain consistent view behavior, avoid unintended reinitializations, and build reactive UIs that respond smoothly to data changes.

In this lecture, you’ll learn how initializers play a central role in implementing dependency injection within SwiftUI views. We’ll explore how passing dependencies—such as a view model—into a view through its initializer promotes clean architecture, separation of concerns, and testability. You’ll see how this approach avoids tightly coupling views to their dependencies, making your code more modular and maintainable. By the end, you'll understand how to structure your initializers to inject dependencies effectively in a SwiftUI and MVVM-based project.

In this lecture, we’ll explore when and why to use @StateObject in SwiftUI, focusing on scenarios where a view owns and manages its own observable state.

In this lecture, we’ll discuss when you should avoid using @StateObject and why @ObservedObject may be the more appropriate choice in those situations.