Course Information
Registration period
Year-round Recruitment
Course Level
Study Mode
Duration
6 Hour(s) 55 Minute(s)
Language
English
Taught by
Mohammad Azam
Rating
Course Overview
Harness the power of SwiftUI framework and start building amazing apps!
MVVM is the default pattern when building SwiftUI applications. I have been personally using the MVVM pattern since the inception of SwiftUI in 2019.
After building hundreds of demos and prototypes, I started to notice issues with using MVVM patterns for SwiftUI applications. These issues resulted in adding needless complexity and constantly fighting the SwiftUI framework.
In this course, I will explain a different pattern for building SwiftUI apps. This pattern is used by Apple to build their SwiftUI applications. The pattern is called the MV pattern, where M stands for Model and V is for View.
Let’s check out the contents of the course:
Understanding MV Pattern
In this section you will learn the thinking behind the MV pattern and how it is different from the MVVM pattern. We will compare SwiftUI with WPF and conclude that in SwiftUI, the View is also the View Model.
Validation
In this section, you will learn how to perform validation using MV pattern. These validation techniques are inspired from the React framework. You will learn how to perform simple validation, inline validation and even validation summary.
Coffee Order - [Project Time]
In this section, you will be building a complete Coffee Ordering application integrated with a JSON API. You will learn how to create an aggregate root model and webservice layer, which allows the app to consume and present data. You will also learn how to write end-to-end tests for your application.
Budget App - [Project Time]
In this section, you will learn how to build a SwiftUI app using MV pattern, which uses Core Data to persist information on the device. You will learn to use property wrappers including @FetchRequest and @Environment, which makes working with Core Data a breeze.
Who is this course for?
Developers who wants to learn Apple’s way of building SwiftUI applications
Developers who wants to stop fighting the SwiftUI framework and start building iOS apps
Developers who wants to start using all the power and flexibility provided by the SwiftUI framework
Developers who wants to write less code to achieve more
This course will serve as an eye opener to many developers and will provide a lot of information on a different and easier way for building SwiftUI applications.
After this course, you will be ready to start building your apps using the MV pattern.
Let’s get started.
Course Content
- 10 section(s)
- 56 lecture(s)
- Section 1 Introduction
- Section 2 Understanding MV Pattern
- Section 3 Validation
- Section 4 Coffee Order App - Getting Started and Displaying Orders
- Section 5 Coffee Order App - End to End Testing and Adding New Coffee Orders
- Section 6 Coffee Order App - Updating and Deleting Orders
- Section 7 Budget App - Setting Up Core Data and Adding Budget Categories
- Section 8 Budget App - Adding Transactions
- Section 9 Budget App - Editing Budget Categories and Deleting Transactions
- Section 10 Conclusion
What You’ll Learn
- Writing SwiftUI apps using MV pattern
- Learn to build SwiftUI apps based on Apple's recommendations
- Learn how MVVM might be adding unnecessary code to your SwiftUI apps
- Learn to write end-to-end tests for your application
- Apply MV pattern for client/server applications
- Learn to build Core Data apps and @FetchRequest and @Environment property wrappers
Skills covered in this course
Reviews
-
DD.P. Coder
I really enjoyed the course — it gave me a lot of new insights, especially in terms of architecture and design approaches. I’m still learning how to build apps. I’ve created a simple training app and am now working on a more complex one. In both projects, I initially tried to follow the MVVM pattern, since it’s mentioned in almost every tutorial on YouTube. My usual process is to write all the logic in the View first, and then gradually move it into a ViewModel. Over time, I started running into limitations: property wrappers don’t work in ViewModels, and I often had to write a lot of boilerplate code or use workarounds that didn’t feel elegant. This led me to explore other architectural patterns, and that’s how I discovered the MV approach, which felt much more logical and flexible for my use case. The only thing I still find challenging is testing. UI tests aren’t always predictable, which was also apparent in the testing lessons from this course. I can definitely recommend this course to beginners, as well as to those who don’t want to overengineer simple features just because they chose MVVM.
-
PPaulo Pimentel
The course is good, but I give 4 stars for the missing parts and video that made difficult to follow the course.
-
AAnonymized User
The view logic in the View not the same with the MVVM so we can't make the UT for this, instead of we make the UI test for this. I think it's not better.
-
CChristopher Selin
As mentioned by others there is a backend piece that isn't covered by the lecture. I was able to get by using the instructor's existing endpoints, but that obviously isn't scalable. Otherwise, it was a solid course where each section added value.
