Mastering SwiftUI Architecture: Patterns and Best Practices

Explore the presentation model and MVVM origins, tracing how early binding between view and view model evolved from Windows Forms to WPF, and how two-way binding simplifies synchronization.

Master the MVVM design pattern by separating the model as domain with business logic, the view as the user interface, and the viewmodel as a data provider for the view.

Explore the limitations of MVVM in SwiftUI and how a single observable object or aggregate models can replace multiple view models, using environment value and bounded contexts.

Take a practical tour of a SwiftUI MVVM app that fetches coffee orders via an HTTP client and navigates a list to a detail and add screen, exploring dependency management.

Remove view models and access a shared HTTP client directly from views via a custom environment value, enabling simple, server-driven order loading with a reusable service.

Move from view models to the environment HTTP client to post orders. Encode to JSON and push results via closures or bindings, then preview the aggregate model pattern for state.

Learn how to replace per-screen view models with a single observable coffee store that manages the app's global state, using environment injection to load and place orders within bounded contexts.

Explore bounded context in a domain-driven SwiftUI architecture, from a food truck model to catalog and order stores connected by a shared network layer.

Split a coffee store app into ordering and employee management stores using bounded context and domain driven design, with environment sharing as the source of truth.

Examine bounded contexts such as patient management and medical records management, and how aggregate roots, data stores, and a network layer for views enable cross-context communication.

Examine nested observables in a SwiftUI expense tracker, showing how nested observable objects affect UI updates and how iOS 17's observable macro simplifies change notifications.

Discover how to fix nested observables in SwiftUI by composing small views that observe an observable object with published properties, and applying the observable macro in iOS 17.

Explore how bounded contexts like medical record management, patient management, and appointments communicate, using HTTP clients, stores, and environment injections to coordinate data across contexts.

Explore how SwiftUI views are declarations rather than renderers, and how they map to UIKit components like CG drawing view, collection view, and UI switch, with debugging insights.

SwiftUI views are actually view models that take data from the model and bind it to the view, using state, binding, environment values, and fetch requests.

Explore how SwiftUI tracks dependencies and rerenders views, contrasting it with React’s rendering model, and learn how dependencies trigger reevaluation of the view.

Explain the screen versus view distinction in SwiftUI, using a container pattern where screens fetch data and pass it to reusable views. Use clear naming to improve organization and reusability.

Group view events in SwiftUI by replacing separate closures with a movie cell events enum, improving reusability and delegating actions to the content view and movie store.

Implement simple validation on a SwiftUI login screen by checking username and password, disable the login button until the form is valid, and use string extensions.

Refactor a SwiftUI driver license form by extracting state into a form model, binding fields, validating SSN format, and displaying errors via a validation summary view.

Learn to replace string arrays with localized error handling in a SwiftUI form, using a localized error enum, error descriptions, and localization files to support multiple languages.

Display login errors with an error wrapper that adds guidance. Present the error via a sheet or overlay and reuse an error view.

Create a global error handling system in SwiftUI by introducing a show error environment key and error wrapper, enabling sheets, modals, and overlays to display sample errors with guidance.

Display errors globally with overlays in SwiftUI; learn to unwrap the error wrapper, bind to an error view, and auto dismiss after two seconds using a task sleep.

Display errors globally in SwiftUI by wrapping content with a custom error modifier, using overlays, bindings, and environment values across sheets and detail views.

Navigate SwiftUI with navigation links, stacks, and destinations, mastering programmatic routing and enum-based and value-based navigation. Compare simple static links to destination-driven patterns for scalable apps.

Learn programmatic navigation in SwiftUI by using a navigation path with a typed, hashable enum of routes to drive transitions across movie, login, and review screens.

Expose a global router as an observable object and inject it into the environment to enable routes across all views, with path-based navigation, previews, and unwinding.

Explore a SwiftUI-inspired, environment-based global navigation pattern using a custom navigate environment value, supporting push and unwind navigation for dynamic, programmatic routing.

Explore programmatic navigation in SwiftUI tab views by giving each tab its own navigation stack with an observable router injected into the environment, enabling dynamic routes and destinations.

Master test driven development by writing a failing test (red), making it pass (green), then refactor without new tests, and balance unit, integration, and end-to-end tests.

Identify why tests often validate frameworks rather than domain logic. Learn to write domain tests for a budget app using Swift data, exploring in-memory versus persistent storage and duplicate-name rules.

Learn to test domain logic in SwiftData by ensuring saving budgets with duplicate names throws a duplicate name error using a save function and budget exists check via fetch descriptor.

Write tests to compute budget expenses total, model expenses with a one to many relationship, and implement spent and remaining calculations, while refactoring to remove duplication.

Refactor both production code and tests by centralizing container and context initialization in a per-test setup, using teardown for cleanup, and validating domain logic in SwiftData.

Understand mocks and stubs in testing managed versus unmanaged dependencies, and how mocks verify interactions with third-party services like a credit score API while stubs provide hard coded responses.

Learn how to stub the credit score service response in unit tests by using a protocol and a mock, enabling fixed scores (like 720) to test apr calculations.

Learn to mock inter-service communication by creating and fulfilling expectations between the Apr service and the credit score service, using a mocked on get credit score closure to drive tests.

Write a unit test that mocks the credit score service to return nil, then verify the APR service throws a credit score not found exception.

Learn why unit tests for a view model don’t verify UI correctness in MVVM, and how UI tests validate the registration form with SSN validation.

Extract view logic into a separate registration form struct, bind fields, and test form validity as a value type, with unit and optional end-to-end tests.

Explore testing presentation logic in SwiftUI by mocking the HTTP client with a protocol, using a mocked data source for previews, and validating product filtering with unit tests.

Explore end to end testing (e2e) as a holistic approach that simulates real user journeys from the user interface through backend processes, databases, and external systems.

Master end-to-end testing in SwiftUI by validating a loan app flow from launch to APR, using staging URLs, accessibility identifiers for SSN text field and submit button, and no mocking.

Load a SwiftUI view in a UIKit app using a UIHostingController. Add a UIKit button to push the SwiftUI stock list screen.

Embed a SwiftUI rating view in a UIKit view controller using UIHostingController, display it as a subview, center it with constraints, and prepare to retrieve the rating later.

Wrap the SwiftUI rating view in a hosting container and expose an observable rating object, then subscribe with Combine to update a UIKit label as the rating changes.

Learn to load a UIKit view into a SwiftUI app using the UIViewRepresentable protocol, implementing makeUIView and updateUIView to wrap a UIActivityIndicatorView controlled by a loading state.

Learn how to embed a UIKit map view in SwiftUI using UIViewRepresentable, configure a map view coordinator as MKMapViewDelegate, and customize annotations with a custom Apple marker annotation.

Learn to load a SwiftUI donut cell into a UIKit table view using UI hosting configuration and cell content configuration.

Preview a view controller in Xcode previews by creating a view controller representable conforming to UI view controller representable and implementing make UI view controller.

Learn to format date and time in SwiftUI using now.formatted with date style and time style options, including omitted, abbreviated, long, numeric, and ISO 8601 formats for flexible user interfaces.

Explore SwiftUI list formatting with the list modifier to display names and numbers using currency, percentages, and end and or separators, localized.