About the course
On this course you'll learn the fundamentals of Swift, Apple's powerful and intuitive programming language, and dive into the modern declarative UI framework, SwiftUI, to build engaging and user-friendly applications for iPhones and iPads.
This hands-on course covers everything from language basics and UI design to data handling, networking, and even preparing your app for the App Store.
You'll gain practical experience through labs and a final case study, equipping you with the skills to create your own modern iOS apps using the latest technologies and best practices.
We'll also explore architectural patterns like MVVM and introduce dependency management using Swift Package Manager to streamline your development workflow.
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.
-
- Write and understand Swift code, applying core language features and best practices.
- Build user interfaces for iOS applications using the modern SwiftUI framework.
- Implement common UI elements, manage layout, and apply styling in SwiftUI.
- Navigate between different screens and manage the lifecycle of an iOS app.
- Store and retrieve application data using various techniques, including Codable and SwiftData.
- Apply the MVVM architectural pattern to structure SwiftUI applications.
- Integrate and consume data from web services in an iOS app using asynchronous operations.
- Manage external libraries and dependencies using Swift Package Manager (SPM).
- Write unit tests to ensure the quality and reliability of iOS applications.
- Understand the process of preparing and delivering an iOS app to the App Store.
-
This course is ideal for aspiring iOS developers, programmers with experience in other languages looking to learn iOS development, web developers wanting to expand their skills to mobile platforms, and anyone with a passion for creating innovative applications for Apple devices.
No prior iOS development experience is necessary, but a basic understanding of programming concepts will be beneficial.
-
To make the most of this course, delegates should have a basic understanding of programming concepts in any language (e.g., variables, loops, conditional statements).
Familiarity with object-oriented programming (OOP) concepts will be helpful but not mandatory.
You'll need a Mac computer running the latest compatible version of macOS. Xcode (Apple's integrated development environment, which is free to download from the Mac App Store) will be required for the hands-on labs.
-
This iOS app development course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction to Swift
Trainer and Delegate Introductions / Intro to course
Foundations of Swift
XCode Playgrounds
Basics of the language: Types, Operators, Conditionals, Iterators, Strings, Arrays, Dictionaries
Lab 1: Trying out the language basics
Introduction to SwiftUI
The structure of a SwiftUI app
Showing views on a single screen
Declarative programming
Using Previews
Lab 2: Trying out SwiftUI basics
SwiftUI Views and controls
Stacks and frames - the idea of ViewBuilders
Common views and controls
Spacers and padding
Applying modifiers to views
Making SwiftUI interface components of your own - Views, Functions and ViewBuilders
Lab 3: Setting out screen layout in SwiftUI
Functions in Swift
Function parameters and results
Argument labels
Default values
Lab 4: Writing functions
Prototyping an interface design
Deciding what goes into the app
Making the screens for a multi-screen app and joining them
Trying out the app on potential users
Taking Apple design considerations and HCI guidelines into account
Lab 5: Building an app prototype with minimum effort
Structs and Classes in Swift
Creating structs and initialising them
Properties and access methods and using them
Classes - Initializers, methods and properties
When to use classes and structs
Lab 6: Creating and using Structs and Classes
Table views
Building a simple table
Lazy stacks and Lists
Adding complex cell structures
Lab 7: Making a multi-screen table-based app
Dictionaries / Optionals / Guard / Scope
Dictionaries/why we need optionals
How to use them correctly
Making code tidy with Guard
Understanding scope of variables
Lab 8: Optionals and Guard
Advanced navigation in SwiftUI
Navigating to sub-screens / passing State / modal sheets
NavigationStack and NavigationSplitScreen
Tab bars
Lifecycle of an app
@main
App struct
scenes
Lab 9: Making a multi-screen table-based app
Protocols, closures
Built in protocols – CustomStringConvertible, Equatable, Comparable, Codable
Defining and implementing your own protocols
Using closures
Shortening closures
Lab 10: Protocols and Closures
Overview of using data in Views
Using Property Wrappers
@State
@Observable
@Environment, @Binding, @Bindable
When to use which access method
Lab 11: Using state in a control
Encapsulating controls
Forms
Using controls available in SwiftUI
Binding variables to controls
Ways of encapsulating a complex control in a reusable view
Lab 12: Building a form to get user details
Location facilities
Setting up location services
Tracking movement
Annotating maps
Lab 13: Adding Maps to an app
Interacting with taps and the accelerometer
Implementing taps and swipes
Using the accelerometer
Lab 14: Example apps using taps, swipes and the accelerometer
iOS Animations
How animations are used in iOS
Delighting users with animations
Types of animation that are possible
Lab 15: Building animations
Data storage with Codable
Application sandbox
Where and how to save data in iOS
Codable with JSON and PLists
Using SwiftData
Lab 16: Extended lab bringing together work on tables, data access and storing data
Architecture of a SwiftUI app
Concepts of MVVM
MVVM in SwiftUI
Using Observables locally and in the environment
Dependency Management with Swift Package Manager (SPM):
Revisiting the importance of dependency management.
Using SPM to add networking libraries / JSON parsing libraries.
Managing different versions of dependencies.
Calling web services and receiving data asynchronously
Error-handling network issues
Data parsing failures
Concurrency
Grand Central Dispatch
async / await
Processing data and updating screens
Lab 17: Reading and processing data from a web service and adding a networking library via SPM to assist integration
Unit Testing
Identifying what to unit test
Setting up tests
Running tests in XCTest
Lab 18: Writing Unit Tests for iOS Apps
Delivering to the App Store
Registering an app
Getting ready to make an app live
Choices for how to deliver an app
App analytics
Bringing it all together in a complex app
Final Case Study
-
developer.apple.com/swift/ - The official Swift programming language website by Apple.
developer.apple.com/xcode/ - Information and downloads for Xcode, Apple's integrated development environment.
developer.apple.com/documentation/swiftui/ - Apple's official documentation for the SwiftUI framework.
swift.org/ - The Swift open-source community website.
Trusted by
