Learn Swift and iOS Development
Master iOS development through in-depth tutorials and comprehensive courses on Swift, SwiftUI, UIKit, Core Data, and more.
7:46
What Is Reactive Programming
Building Reactive Applications With RxSwift
Building Reactive Applications With RxSwift is a practical introduction to reactive programming. Reactive programming asks for a new mindset. You need to think differently and that may take a bit of time. Reactive programming changes how you think about code and that is what trips up many developers that are new to reactive programming.
in RxSwift
8:21
Choosing Between Closures and Delegation
Mastering Navigation With Coordinators
There are several options for sending messages from a view controller to its coordinator. Up until now we exclusively used closures to notify the coordinator. Another option is delegation and that's the pattern we explore in this episode.
in Patterns
6:32
MVVM-C and Separation of Concerns
Mastering Navigation With Coordinators
In the previous episode of Mastering Navigation With Coordinators, we refactored the PhotosViewController class. It now uses the MVVM pattern instead of the MVC pattern. We migrated the project from the MVC-C pattern to the MVVM-C or Model-View-ViewModel-Coordinator pattern.
in Patterns
11:02
The Model-View-ViewModel-Coordinator Pattern
Mastering Navigation With Coordinators
Earlier in this series, I mentioned that the coordinator pattern works well with the Model-View-ViewModel pattern. The resulting pattern is commonly referred to as MVVM-C or the Model-View-ViewModel-Coordinator pattern. In this episode, we refactor the PhotosViewController class. It currently uses the Model-View-Controller pattern. We update the implementation of the PhotosViewController class to use the Model-View-ViewModel pattern instead. I won't cover the details of the MVVM pattern in this episode, though. The MVVM pattern is covered in detail in Mastering MVVM With Swift.
in Patterns
13:15
Adopting the Coordinator Pattern
From Zero to App Store
In this episode, we adopt the coordinator pattern. I won't cover the details of the coordinator pattern in this episode, though. Coordinators are covered in detail in Mastering Navigation With Coordinators.
in Programming
10:19
Working With Tab Bar Controllers
Mastering Navigation With Coordinators
There's a common scenario we haven't covered in this series. How do you use a tab bar controller in combination with coordinators? The coordinator pattern is a flexible design pattern and there are several options for using a tab bar controller in combination with coordinators.
in Patterns
8:27
Dependency Injection and the Coordinator Pattern
Mastering Navigation With Coordinators
If you're familiar with Cocoacasts, then you should know that I'm a big proponent of dependency injection. I tend to discourage developers from using the singleton pattern if the goal is creating an object that is easily accessible from anywhere in the project. That's not what the singleton pattern is about. You can learn more about the singleton pattern by reading Are Singletons Bad.
in Patterns
5:35
Storyboards, XIBs, and Code
Mastering Navigation With Coordinators
The Photos project exclusively uses storyboards to design and create view controllers. In this episode, I show you that the coordinator pattern isn't limited to storyboards. You can also use the coordinator pattern if you prefer XIB files over storyboards. If you prefer to use neither, then that's possible too. It doesn't matter how you design and create the view controllers of your project.
in Patterns
10:02
Combining Horizontal and Vertical Flows
Mastering Navigation With Coordinators
In the previous episodes, we added support for a vertical purchase flow. Most applications are a puzzle of horizontal and vertical flows. Combining horizontal and vertical flows allows for flexible and dynamic application flows.
in Swift
11:35
Switching Between Horizontal and Vertical Flows
Mastering Navigation With Coordinators
We successfully converted the horizontal purchase flow to a vertical purchase flow in the previous episode. The BuyCoordinator and VerticalBuyCoordinator classes have quite a bit in common. In this episode, we add the ability to the BuyCoordinator class to manage both flows by merging the VerticalBuyCoordinator class into the BuyCoordinator class.
in Patterns
10:57
Managing Horizontal and Vertical Flows
Mastering Navigation With Coordinators
I hope this series has convinced you of the value of the coordinator pattern. You should have a good understanding of the pattern by now and be able to adopt it in a project. In the remainder of this series, we cover more advanced aspects of the coordinator pattern. In this and the next episodes, we zoom in on horizontal and vertical flows. Let's start by discussing the differences between horizontal and vertical flows.
in Patterns
12:00
Working With Navigation Controllers
Mastering Navigation With Coordinators
At the end of the previous episode, we discovered and resolved a memory issue. When the user completes the purchase flow, the BuyCoordinator instance is deallocated by removing it from the array of child coordinators.
in Patterns