Jacobs - Mastering MVVM With Swift: Updated for Xcode 9 and Swift 4

Welcome to Mastering MVVM With Swift. Im glad to see you here. In this book, you learn the ins and outs of the Model-View-ViewModel pattern. The goal of this book is to provide you with the ingredients you need to implement the Model-View-ViewModel pattern in your own projects.

This book uses Xcode 9 and Swift 4. Only the chapters about reactive programming stick with Xcode 9 and Swift 3. These chapters will be updated once RxSwift/RxCocoa officially support Swift 4. If you want to follow along, make sure you have Xcode 8 or 9 installed on your machine. Everything you learn in this book applies to both Swift 3 and Swift 4.

This book covers much more than the Model-View-ViewModel pattern. We start with an overview of the Model-View-ViewModel pattern and we compare it with the popular Model-View-Controller pattern, a pattern youre probably already familiar with.

In the remainder of the book, we refactor Cloudy, a weather application powered by the Model-View-Controller pattern. We refactor Cloudy to use the Model-View-ViewModel pattern instead. This will show you how to apply the Model-View-ViewModel pattern in a production application. The refactoring operation will show you exactly what needs to change to move from MVC to MVVM, highlighting the benefits and challenges that go with this migration.

Along the way, you learn what view models are, how to create them, and how to use them in view controllers. We further simplify the view controllers of the project using protocol-oriented programming. Protocols and MVVM work very well together.

Later in the book, we write unit tests for the view models we created. One of the key benefits of the Model-View-ViewModel pattern is improved testability and thats something I want to show you first-hand. Writing unit tests for view models is really easy.

The Model-View-ViewModel pattern really shines with the help of bindings. I first show you how to create a custom bindings solution. This is an important step as it will show you how the Model-View-ViewModel pattern and bindings work under the hood.

Later in the book, we take it a step further by taking advantage of RxSwift and RxCocoa. You dont need to be familiar with reactive programming to understand these chapters. We primarily focus on the Model-View-ViewModel pattern and how it plays together with bindings. The Model-View-ViewModel pattern works with any bindings solution.

We end this book with a quick recap of what we gained from using the Model-View-ViewModel pattern instead of the Model-View-Controller pattern. The changes we apply to Cloudy are pretty dramatic and Im sure youll appreciate the benefits the Model-View-ViewModel pattern has to offer.

This book covers a lot of ground, but Im here to guide you along the way. If you have any feedback or questions, reach out to me via email (bart@cocoacasts.com) or Twitter (@_bartjacobs). Im here to help.

If youd like to follow along, I recommend downloading the source files that come with this book. The chapters that include code each have a starter project and a finished project. This makes it easy to follow along or pick a random chapter from the book. Click here to download the source files for this book. If youre new to the Model-View-ViewModel pattern, then I recommend reading every chapter of the book.

Not everyone likes books. If you prefer video, then you may be interested in a video course in which I teach the Model-View-ViewModel pattern. The content is virtually identical. The only difference is that you can see how I refactor Notes using the Model-View-ViewModel pattern. You can find the video course on the Cocoacasts website.

1 Is MVC Dead

Model-View-Controller, or MVC for short, is a widely used design pattern for architecting software applications. Cocoa applications are centered around the Model-View-Controller pattern and many of Apples frameworks make heavy use of the Model-View-Controller pattern.

Last year, I was working on the next major release of Samsara, a meditation application Ive been developing for the past few years. The settings view is an important aspect of the application.

Samsaras Settings View

From the perspective of the user, the settings view is nothing more than a collection of controls, labels, and buttons. Under the hood, however, lives a fat view controller responsible for managing the content of the table view and the data thats fed to the table view.

Table views are flexible and cleverly designed. A table view asks its data source for the data it needs to present and it delegates user interaction to its delegate. That makes them incredibly reusable. Unfortunately, the more the table view gains in complexity, the more unwieldy the data source becomes.

Table views are a fine example of the Model-View-Controller pattern in action. The model layer hands the data source (mostly a view controller) the data the view layer (the table view) needs to display. But table views also illustrate how the Model-View-Controller pattern can, and very often does, fall short. Before we take a closer look at the problem, Id like to take a brief look at the Model-View-Controller pattern. What is it, what makes it so popular, and, more importantly, what are its drawbacks?

What Is It?

The MVC pattern breaks an application up into three components or layers:

• Model
• View
• Controller

Model

The model layer is responsible for the business logic of the application. It manages the application state. This also includes reading and writing data, persisting application state, and it may even include tasks related to data management, such as networking and data validation.

The M In MVC

View

The view layer has two important tasks:

• presenting data to the user
• handling user interaction

A core principle of the MVC pattern is the view layers ignorance with respect to the model layer. Views are dumb objects. They only know how to present data to the user. They dont know or understand what theyre presenting. This makes them flexible and easy to reuse.

The V In MVC

Controller

The view layer and the model layer are glued together by one or more controllers. In an iOS application, that glue is a view controller, an instance of the