About the course
SwiftUI represents a significant evolution in how user interfaces are built across Apple platforms, moving away from the imperative and constraint-heavy approach of UIKit and Autolayout towards a modern, declarative paradigm. For experienced iOS developers already proficient in Swift and UIKit, mastering SwiftUI is crucial for building efficient, maintainable, and cutting-edge applications that leverage the latest platform features. This 4-day intensive hands-on upskilling training course is specifically designed to equip existing iOS app developers with the knowledge and practical skills necessary to confidently develop user interfaces using SwiftUI, integrate it into their workflow, and understand how it interacts with existing UIKit codebases.
The course begins by introducing the fundamental concepts of SwiftUI, including the principles of declarative programming, understanding the structure of a SwiftUI app, composing views, and effectively utilising Xcode Previews for rapid UI iteration. Participants will then gain a deep understanding of SwiftUI's powerful and flexible layout system, learning how to effectively replace Autolayout by mastering the use of Stacks (VStack, HStack, ZStack), Frames, Spacers, and applying Modifiers to views. The training demonstrates how to create reusable custom interface components and views using SwiftUI's lightweight syntax, Functions, and ViewBuilders.
Building on layout fundamentals, the course covers implementing common and essential UI patterns, including building Lists (List and LazyStack) to display collections of data, handling complex cell structures, and implementing multi-screen navigation using modern SwiftUI components like NavigationStack and NavigationSplitView, along with effectively passing state between screens. A core focus is placed on SwiftUI's approach to managing data flow and state using Property Wrappers like @State, @Observable, @Environment, @Binding, and @Bindable, explaining their appropriate use cases and demonstrating how to bind data to standard SwiftUI Controls and encapsulate complex control logic within reusable views. Participants will also explore architectural patterns suitable for SwiftUI, focusing on applying the MVVM (Model-View-ViewModel) concept, structuring apps, and using Observable objects for data management, including in the environment. The course covers handling asynchronous calls, such as web service access and continuous data streams, within the SwiftUI data flow using observable results. Finally, the training addresses the practical reality of migrating to or integrating SwiftUI by demonstrating techniques for linking SwiftUI and UIKit, allowing developers to embed views and screens from one framework into the other. The course culminates in a comprehensive case study where attendees will apply all the learned concepts to build a significant, multi-screen, data-driven application, solidifying their skills for real-world SwiftUI development.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Understand the core principles of SwiftUI and declarative programming and differentiate it from the UIKit development paradigm.
- Master SwiftUI's modern layout system, including using Stacks, Frames, Spacers, and Modifiers, and create reusable custom view components.
- Implement common UI patterns such as Lists (List, LazyStack), complex cell structures, and multi-screen navigation using SwiftUI components (NavigationStack, NavigationSplitView).
- Effectively manage data flow and state in SwiftUI applications using key Property Wrappers (@State, @Observable, @Environment, @Binding, @Bindable) and understand when to use each.
- Build interactive user interfaces using standard SwiftUI Controls, Forms, and Modal sheets, and correctly bind data to controls.
- Apply the MVVM architectural pattern when structuring SwiftUI applications and effectively utilise Observable objects for data management locally and in the environment.
- Implement handling of asynchronous operations (e.g., web service calls, continuous data streams) and integrate the results into the SwiftUI data flow using observable results and Environment objects.
- Understand and apply techniques for linking SwiftUI and UIKit, enabling the integration and interoperability between views and screens built in both frameworks.
- Apply comprehensive SwiftUI development skills learned throughout the course to build a multi-screen, data-driven application based on a real-world case study.
-
This intensive hands-on upskilling training course is specifically designed for experienced iOS app developers who are familiar with Swift and UIKit and want to learn how to build modern user interfaces using SwiftUI. It is ideal for:
iOS Developers currently building applications with UIKit who want to transition to or incorporate SwiftUI into their projects.
Developers looking to understand the declarative programming paradigm and its application in iOS development.
iOS Developers needing to learn modern data management and architectural patterns suitable for SwiftUI.
Development teams planning to adopt SwiftUI for new projects or integrate it into existing UIKit codebases.
-
Participants should have attended our Modern iOS app development with Swift course or have equivalent experience:
Experience developing iOS applications using Swift (and the UIKit framework).
A solid understanding of common iOS development concepts (e.g., view controllers, delegation, protocols, asynchronous operations, basic data handling).
-
Introduction to SwiftUI
Trainer and Delegate Introductions / Introduction to the course and SwiftUI's place in Apple development.
The structure of a SwiftUI app.
Showing views on a single screen.
Understanding Declarative programming principles compared to imperative.
Using Previews for rapid UI iteration.
Lab 1: Trying out SwiftUI basics - Creating simple views and understanding the structure.
Replacing Autolayout
Understanding SwiftUI's layout system as a replacement for Autolayout.
Stacks (VStack, HStack, ZStack) and frames - the idea of ViewBuilders.
Spacers and padding for fine-tuning layout.
Applying modifiers to views.
Making SwiftUI interface components of your own - Creating reusable Views, Functions, and ViewBuilders.
Lab 2: Setting out screen layout in SwiftUI - Building complex layouts using stacks, frames, and modifiers.
Table views and navigation
Building a simple table (List and LazyStack).
Adding complex cell structures within Lists.
Navigating to subscreens / passing State.
Using modern navigation containers: NavigationStack and NavigationSplitScreen.
Lab 3: Making a multi-screen table-based app - Implementing lists with custom cells and navigation.
Overview of using data in Views
Understanding data flow in SwiftUI.
Using Property Wrappers for data management.
@State: Managing local view state.
@Observable: Managing observable objects (often for models/view models).
@Environment, @Binding, @Bindable: Sharing state and creating two-way bindings.
When to use which access method and property wrapper.
Lab 4: Using state in a control - Implementing data binding with a simple control.
Controls and Forms
Building user interfaces with standard controls available in SwiftUI (e.g., TextFields, Toggles, Buttons).
Binding variables to controls to create interactive elements.
Creating complex Forms.
Presenting content modally using Modal sheets.
Ways of encapsulating a complex control in a reusable view.
Lab 5: Building a form to get user details - Creating a form with multiple controls and handling input.
Architecture of a SwiftUI App
Concepts of architectural patterns, focusing on MVVM (Model-View-ViewModel).
Applying MVVM principles in SwiftUI development.
Structuring our app using MVVM.
Using Observables locally and in the environment for data management in MVVM.
Lab 6: Building an app with MVVM - Restructuring a simple app using the MVVM pattern.
Asynchronous calls with SwiftUI
Example UIKit app using callback for async operations (brief review).
Equivalent in SwiftUI with observable results and data flow.
Using Environment objects or Observable objects as managers for asynchronous operations (e.g., networking).
Lab 7a: Accessing web services - Fetching data from a remote API and displaying it.
Lab 7b: Reading continuous data - Handling data streams or updates.
Linking SwiftUI to your UIKit app
Understanding the ways of linking SwiftUI and UIKit.
Extending SwiftUI by linking to or embedding a UIKit screen (UIViewControllerRepresentable).
Extending UIKit by building in or embedding some SwiftUI (UIHostingController).
Lab 8a: Extending a network app to an in-app browser - Potentially integrating a UIKit WebView.
Lab 8b: Adding SwiftUI to your UIKit app - Embedding a SwiftUI view into a UIKit screen.
Lab 8c: Adding a UIKit view to a SwiftUI app - Embedding a UIKit view within SwiftUI.
Final case study
Lab 9: Building chosen app - Participants will be given a case study app to build, such as a conference programme app with multiple screens and interaction. The case study is based on a real-world example (like the iOSDevUK conference app). Delegates will be provided with necessary components (ViewModel, model, data) but will apply learned SwiftUI concepts to build the UI and integrate the data.
Alternatively, where delegates have other specific challenges from their own work that they wish to explore, they will be supported in finding out how their challenges can be met using SwiftUI, applying the principles learned throughout the course.
-
SwiftUI Documentation (Apple Developer): The official and most authoritative source for SwiftUI information.
Swift Programming Language Guide (Apple Developer): The official documentation for the Swift language.
Combine Framework Documentation (Apple Developer): Essential documentation for the Combine framework, often used with SwiftUI for handling asynchronous events and data streams.
Trusted by
