Learn Swift and iOS Development
Master iOS development through in-depth tutorials and comprehensive courses on Swift, SwiftUI, UIKit, Core Data, and more.
3:25
Welcome to Mastering MVVM With Swift
Mastering MVVM With Swift
Welcome to Mastering MVVM With Swift. In this series, you learn the ins and outs of the Model-View-ViewModel pattern. The goal is to provide you with the ingredients you need to implement the Model-View-ViewModel pattern in your own projects.
9:10
How to Use a Capture List to Break a Retain Cycle
Understanding Swift Memory Management
If you have been paying attention, then you may have noticed that we haven't resolved the strong reference cycle we introduced between the root view controller and the settings view controller earlier in this series. This is what the implementation of the RootViewController class looks like.
6:49
What Is the Difference Between Strong, Weak, and Unowned References
Understanding Swift Memory Management
In the previous episode of Understanding Swift Memory Management, you learned how weak and unowned references can break a strong reference cycle. What sets weak and unowned references apart from strong references? What is the difference between weak and unowned references? When is it appropriate to choose an unowned reference over a weak reference? We tackle these questions in this episode.
7:33
How to Break a Strong Reference Cycle
Understanding Swift Memory Management
Strong reference cycles negatively impact your application's performance. They lead to memory leaks and unexpected behavior that is often hard to debug. In this episode, I show you how to resolve the strong reference cycles we created in the previous episode of this series.
7:05
What Are Strong Reference Cycles
Understanding Swift Memory Management
In the previous installment of this series, you learned about Automatic Reference Counting and how it helps keep memory management in check. Remember that a class instance is deallocated if no properties, constants, or variables hold a strong reference to the class instance. I didn't explain what a strong reference is, though.
11:30
What Is Automatic Reference Counting (ARC)
Understanding Swift Memory Management
Before we can discuss Automatic Reference Counting, ARC for short, you need to understand the difference between value types and reference types.
7:39
Taking Advantage of Swift's Native Result Type
Swift and Cocoa Essentials
Most of the Cocoa APIs we use to build applications are driven by Objective-C. This doesn't mean we need to use Objective-C to take advantage of these APIs, but it does mean that the APIs lack some of the niceties you expect from a Swift API.
in Fundamentals
10:54
Dependency Injection and the Coordinator Pattern
Understanding Scene-Based Applications
The scene-based API has confused many developers, especially those new to the platform. I hope the previous episodes have given you the foundation you need to use the API in your own projects. In this episode, I show you how dependency injection and the coordinator pattern fit into the scene-based API.
in UIKit
11:28
Restoring State of a Scene-Based Application
Understanding Scene-Based Applications
State restoration is an essential component of scene-based applications. Apple introduced view-controller-based state restoration several years ago in iOS 6. The company deprecated view-controller-based state restoration in iOS 13 in favor of user-activity-based state restoration. In this episode, you learn what user-activity-based state restoration is and how you can adopt it in your projects.
in UIKit
11:39
Exploring the User Interface Life Cycle
Understanding Scene-Based Applications
In the previous episode, we created a scene-based application using Xcode's new Single View App template. The target's Info.plist contains a key with name Application Scene Manifest, indicating that the application adopts the scene-based API. The value is a dictionary with two keys, Enable Multiple Windows and Scene Configuration. The value of Enable Multiple Windows is set to NO by default.
in UIKit
11:26
Exploring the Application Life Cycle
Understanding Scene-Based Applications
On iOS 13 and later, applications can support multiple windows on iPad. This is a welcome addition and it takes multitasking to another level on iPad. On iOS 12 and earlier, applications manage one user interface and, typically, one window. To add support for multiple windows, Apple was forced to drastically redesign the application and user interface life cycles on iOS.
in UIKit
7:51
Adding Supplementary Views With Compositional Layouts
Modern Performant Collection Views With Swift
The past episodes have illustrated that creating a compositional layout isn't difficult or complex. The API of the UICollectionViewCompositionalLayout class is intuitive and flexible. In this episode, we revisit the feed view controller one more time. The plan is to display a title at the top of the feed view controller's collection view using a supplementary view.
in Programming