1. Select product
2. Customize order
3. Confirmation
Get the best practices professional iOS developers use to create well-structured SwiftUI apps ready for the App Store
Stop copying other people’s code and feeling like you don’t know anything. Get the definitive roadmap with all the essential concepts that will give you a strong mental model of what makes a complete SwiftUI app
One-time offer
Upgrade now and get two extra products for free. This exclusive one-time offer is only available now because you just joined The SwiftUI Architecture Audit.
Just $297 $451
SwiftUI Structural Foundations
$297
The practical course to build a solid understanding of SwiftUI foundations, enabling you to create any iOS app with confidence.
The SwiftUI Compendium
$77 FREE
The missing SwiftUI manual designed for aspiring iOS developers seeking to understand the basics of SwiftUI through a practical project, leveraging Apple’s official documentation.
Git for iOS Development
$77 FREE
The practical course to fully use Git, safeguard your Xcode projects, and share code with other iOS developers without being frightened by Git’s arcane-sounding commands.
SwiftUI Structural Foundations is an online course focusing on the best patterns and practices for structuring the code of fully featured iOS apps.
Here’s why this course is perfect for you:
- Say goodbye to the feeling of doing things wrong. Move past basic to-do list apps and copy-pasting the code of others, and start structuring your own apps with complex navigation, confident that you’re doing it the right way.
- Go beyond simple tutorials lacking the concepts you must apply to your SwiftUI code and stop wasting time with incomplete and insignificant examples.
- Gain insights into the design patterns used by successful apps in the App Store. Learn from the best practices used by professional developers at big companies and avoid common mistakes.
- Eliminate messy code that feels unnatural and is difficult to debug. Understand where each piece of code should go and learn how to write reusable and maintainable code.
- Get step-by-step instructions and efficient learning material, providing the necessary foundational concepts to work on your own apps. Discover where to begin, how to progress, and the essential knowledge you need to move forward.
If you’re searching for a comprehensive course that covers the skills distinguishing good developers from bad ones, SwiftUI Structural Foundations is the course you need.
The course modules show you the roadmap to structure large SwiftUI projects. You will develop the correct mental models and overcome any doubt when making architectural decisions for your app.
“I am really glad that I found your material. In other resources, I get bits and pieces, but in your courses, I get the fuller picture. It almost feels like I’m cheating when I see other developers struggle with fundamental concepts.” – Adrian Tineo
How SwiftUI Structural Foundations works
The course contains video lessons that explain how SwiftUI works and the best practices for structuring your code. I didn’t know these insights when I started my first iOS developer job, and they took me several years to grasp.
Module 1
Software Design Principles and Structural Patterns
- Why it is better to start with design patterns and best practices when writing well-structured and testable apps rather than diving straight into writing code like in tutorials. Design patterns provide a detailed roadmap that you can use to build any app.
- The three fundamental architectural concepts that govern the development of every iOS app and the dangerous consequences of disregarding them. Developers who merely copy and paste code from tutorials fail to grasp these essential concepts.
- The significance of the MVC and MVVM patterns, which serve as the core design patterns for SwiftUI apps. Design patterns play a crucial role in writing software that is well-designed and robust. Neglecting them will inevitably result in battling against the platform and introducing hard-to-fix bugs.
- The critical differences between Swift structures and classes. A comprehensive understanding of how value and reference types work is essential to prevent unexpected issues, particularly within SwiftUI’s declarative syntax.
Module 2
Modularizing SwiftUI Code
- Functions, closures, and view builders, some of the Swift language features that enable SwiftUI’s declarative syntax. Understanding these features will enhance your comprehension of how SwiftUI works and help resolve any cryptic errors in Xcode.
- Leveraging Xcode previews to speed up interface development and how to effortlessly supply them with preview data that does not depend on external factors, making sure your previews always work.
- The best practices for creating modular SwiftUI views that remain detached from your app’s model. This approach yields robust views that do not break even when your data model changes and are easily previewed in the Xcode canvas.
Module 3
View Modifiers and the Layout of Complex SwiftUI Interfaces
- The SwiftUI layout system: a simple yet powerful three-step process that positions your views on the screen, even for the most sophisticated user interfaces.
- The Swift programming techniques that enable SwiftUI’s view modifiers and guide you in creating custom modifiers that replicate the behavior of those provided by the framework.
- How to use Xcode tools and shortcuts to organize your code into navigable sections, generate boilerplate code, reuse common code snippets, and efficiently navigate large projects.
Module 4
Adding Events and Data Flow to SwiftUI Views and Enable User Interaction
- Storing mutable state in a single source of truth and understanding how changes trigger SwiftUI’s drawing process. Many developers with limited knowledge are unaware of how SwiftUI’s structural identity functions, resulting in interfaces that exhibit unexpected behavior.
- Creating actions for interactive views by utilizing capturing closures that can modify the global state of a view, even when employing simple Swift structures.
- Using bindings to propagate data changes up the view hierarchy, including how to chain them to access the application’s single source of truth and leveraging them to enable interactive views in the Xcode preview canvas.
Module 5
Structured Interactive Interfaces with Dynamic Data
- The SwiftUI list, the most used and versatile vertically scrolling interface for handling dynamic data and navigation. Including how to quickly enable reordering and deleting of rows while keeping the editing code organized within dedicated methods and how to avoid conflicts with identifiable data.
- The essence of protocol-oriented programming and how to share standard functionality across the model of your app, even when dealing with value types such as structures and
- How to construct modular views for editable list elements and bind them to individual values in a Swift collection. Additionally, the guidelines on organizing files in a large Xcode project to ensure easy access during feature development.
Module 6
Navigation Hierarchies and Data Flows
- The SwiftUI environment, the mechanism that effortlessly channels data to any view, eliminating the need for countless stored properties. Plus, the seamless three-step process for storing your custom types in the environment.
- How to use SwiftUI’s structural paradigms to streamline navigation in even the most intricate apps. Explore the best practices of combining navigation views and presentation modifiers to forge complex navigation flows while maintaining a clean separation between your view hierarchy and data model.
- Crafting powerful view modifiers that tap into environment values, affecting entire view subtrees. This technique, often overlooked in other resources, is a crucial ingredient for making your code more expressive, like the one offered by the SwiftUI framework.
Module 7
Structuring a Fully-featured SwiftUI App
- The SwiftUI mechanisms to connect views to objects and seamlessly share state across your navigation hierarchy. Including how to manage data editing flows and ensure changes propagate only when data is saved.
- Creating controller hierarchies to effectively manage the global state of even the most complex apps. Discover the secret many developers overlook – you can have more than one single source of truth in a SwiftUI app.
- How to extend the MVC and MVVM patterns, adding a root layer that orchestrates navigation, global state, networking, data flows, and user interaction. This separation of roles simplifies your view code significantly.
- Using mocking and dependency injection to effortlessly preview SwiftUI views connected to intricate networks of objects that are otherwise hard or impossible to instantiate. Plus, learn techniques to detach content views from objects, making previews a breeze.
“Being able to have such a direct look at Matteo’s way of thinking, you end up catching his enthusiasm, and you want to put together objects that work as they should, with a good architectural design.
This course is not just for beginners but quite the opposite. It is one of the most advanced courses I have done so far (and I have done many), where one can truly learn, since he speaks to you as a human being, explaining all the details.
Don’t think twice. Investing in Matteo’s course is investing in being a top-level iOS developer. You will not find better material.” – Alejandro Mohamad
An unbeatable guarantee: try SwiftUI Structural Foundations for a full 60 days, 100% risk-free
If this course does not help you advance your understanding of SwiftUI and iOS, I insist that you get 100% of your money back.
I’ll even eat the credit card processing fees.
Let me tell you why I offer this unbeatable guarantee.
I looked at many other books and courses and saw that they all follow the same approach. They make you do some exercises and assume you will magically understand the best practices of iOS development. Some courses try to teach you programming and iOS development simultaneously, giving you a poor understanding of both.
My research showed me that several students are left more confused by these courses and cannot put into practice what they learn. I believe my approach can help many to get back on the right track.
That’s why I guarantee SwiftUI Structural Foundations.
Are there any catches to my offer? Not at all, but there is one simple stipulation. I’m sure you’ll agree that it’s pretty reasonable.
I know without a shadow of a doubt from my students the value my course produces, even for developers already familiar with making iOS apps. I have plenty of testimonials that show that.
What I don’t know is whether you’ll study the material as I structured it and apply the techniques that I explain to your work. So, I ask only that you agree to follow through and document you did so.
If you want to join the course because you are curious, coast along, check lessons at random, or even leave the course aside to gather dust, that is your prerogative. Your time and money are yours to dispose of as you please. But I cannot take responsibility for your inaction.
It’s really simple. Take the course and see for yourself. If it does not work, I want you to email me and prove that you made a good-faith attempt to follow the course, and I will refund you 100% of your money.
This guarantee extends for a full 60 days after you join, which is more than enough to go through the ENTIRE course, absorb the material, and put it into practice.
If you don’t love it, email me at ANY TIME during the first 60 days, and show me you’re applying the material, but it does not work for you. I’ll refund 100% of your price.
By the way, I ask you to show me that you’ve applied the concepts I teach because I know how powerful they can be when used.
I have no intention of keeping your money if you’re dissatisfied, but I insist that you commit to taking action if you want the results from this program. Skipping the work, reading a few random lessons, and doing the same things you did before will not make any difference.
I’ve spent years to learn these concepts and more years developing this course, and I’d like to share it with you if you’re ready to finally call yourself an iOS developer.
“I was doubtful because the course is not published on any of the major education platforms. But it has been, without a doubt, the best decision regarding online-paid courses I’ve ever made.
What gave me trust was being able to read Matteo’s free articles and compare them with what I’d previously read. If I had this impression reading his free content, what could I be missing out from a full course?
I can surely say the content’s quality and the architectural approach Matteo delivers are exceptional on both of his courses.” – Alejandro Jimenez