Mastering MVVM With Swift
Mastering MVVM With Swift
$49.00
Minimum price
$49.00
Suggested price
Mastering MVVM With Swift

This book is 100% complete

Completed on 2017-11-29

About the Book

Massive View Controller Syndrome

Firing up Xcode and starting a new project is a great feeling. The first few days or weeks don’t feel like work. Everything goes according to plan.

But as the code base of your project grows, it becomes harder and harder to manage the project. The view controllers of your project start to put on weight … a lot of weight. They become more than view controllers. They take on responsibilities they didn’t sign up for. Don’t they?

Yet you’ve done everything right. You’ve stuck to the rules of the Model-View-Controller pattern. Why have you coded yourself in a corner? And why is it frustrating or downright scary to add features or refactor existing functionality?

It’s Time to Cure MVC

If your project is suffering from Massive View Controller syndrome, then the Model-View-ViewModel pattern is the cure to your problem. The Model-View-ViewModel pattern has been around for many, many years, but it only recently gained traction in the Cocoa community.

MVVM extends MVC by resolving common issues. The result is a robust application architecture with lean view controllers, improved testability, and a better separation of concerns. How does that sound?

Take Control of Your Project With MVVM

In Mastering MVVM With Swift, we refactor an existing application built with MVC to use MVVM instead. The results are dramatic and the MVVM pattern is surprisingly easy to adopt in your own projects.

You learn the differences between Model-View-Controller and Model-View-ViewModel, highlighting the benefits Model-View-ViewModel has over Model-View-Controller.

After a short introduction, we take an application built with Model-View-Controller and refactor it to use Model-View-ViewModel instead. Along the way, you learn about the anatomy of view models, how to create them, and how to test them.

Last but not least, we add protocols and protocol-oriented programming to the mix to further simplify the view controllers in the project.

At the end of this course, you have the knowledge and, more importantly, the hands-on experience to apply Model-View-ViewModel in your own projects.

Ready for Xcode 9 and Swift 4

In Mastering MVVM With Swift, you learn everything you need to know to integrate MVVM in a new or an existing Swift project. We focus on the key aspects of the pattern and refactor an application that takes advantage of the core features of MVVM. We use the latest and greatest to build an application, which means we use Xcode 9 and Swift 4.

Battling Massive View Controller Syndrome

Are the view controllers of your projects suffering from Massive View Controller syndrome? You’ve carefully crafted the architecture of your application using the Model-View-Controller pattern and, yet, the view controllers of your project are ready to burst and they’re impossible to test.

Adding a feature forces you to wade through hundreds of lines of code. You hope you don’t break anything while you carefully add a few lines of code. Don’t get me wrong. Your code isn’t bad. But there’s just so much of it. You’ve applied the Model-View-Controller pattern like you were told to and you still end up with an architecture you aren’t quite happy with. Does this sound familiar?

It’s Not You. It’s MVC.

Because Apple’s frameworks are impregnated with the Model-View-Controller pattern we think it’s the right or only tool for the job. Don’t make the same mistake. There’s nothing wrong with the Model-View-Controller pattern, but there are better alternatives, especially if you’re using Swift.

Put Your View Controllers On a Diet

It’s time to put the view controllers of your project on a diet. I’m sure you’ve heard about the Model-View-ViewModel pattern. It’s the new cool kid in town. But the thing is that it isn’t a kid. MVVM has been around for many, many years and has earned its stripes. It’s a proven strategy for robust, scalable applications.

Where Should This Code Go?

I bet you’ve asked yourself many times “Where should I put this piece of code?” Every developer asks himself/herself this question, multiple times a day. If you’re still using MVC, then chances are that the answer is “the view controller”. Stop. Give MVVM a shot. You can thank me later.

MVVM is a perfect fit for Cocoa applications powered by Swift. The view model unburdens the view controller from the ungrateful task of data manipulation and transformation. The result is a focused, testable view model and a skinny, lightweight view controller.

About the Author

Bart Jacobs
Bart Jacobs

My name is Bart Jacobs and I run a mobile development company, Code Foundry. I’ve been programming for more than fifteen years, focusing on Cocoa development soon after the introduction of the iPhone in 2007.

Over the years, I’ve taught thousands of people about Swift and Cocoa development. Through my experience teaching, I’ve discovered and learned about the main problems people struggle with.

I created Cocoacasts to offer a roadmap for anyone interested in learning Swift and Cocoa development. Through Cocoacasts, I provide a clear path to learn the tools, the language, and the frameworks you need to master Swift and Cocoa development.

I currently work as a freelance developer and teach people about Swift and Cocoa development. While I primarily focus on developing software for Apple’s platforms, I consider myself a full stack developer with a love and interest for Swift and Ruby development.

You can find me on TwitterFollow me and say hi. You can also follow Cocoacasts on Twitter if you’re interested in what I teach on Cocoacasts.

Bundles that include this book

Mastering Core Data With Swift
Mastering MVVM With Swift
$98.00
Suggested Price
$59.00
Bundle Price
Mastering Core Data With Swift
Mastering MVVM With Swift
The Missing Manual for Swift Development
$147.00
Suggested Price
$79.00
Bundle Price

Reader Testimonials

Damian Esteban
Damian Esteban

Chief Technology Officer, betterPT

Even though I was already familiar with MVVM, Bart’s course showed me a different perspective on MVVM by refactoring a complete application built with MVC. He illustrates how MVVM can improve a project’s architecture and testability, and how reactive programming fits in.

Jake Young
Jake Young

Chief Information Officer, ACP Decisions

A big thank you. This has been the single most effective course I've taken about iOS. I put it into practice right away and our App Store app, and its testing, has benefited greatly.

Table of Contents

  • Welcome
    • Xcode 9 and Swift 4
    • What You’ll Learn
    • How to Use This Book
  • 1 Is MVC Dead
    • What Is It?
    • Advantages
    • Problems
    • An Example
    • How Can We Solve This?
  • 2 How Does MVVM Work
    • Advantages of MVVM
    • Basic Rules
    • It’s Time to Refactor
  • 3 Meet Cloudy
    • Application Architecture
  • 4 What Is Wrong With Cloudy
    • Day View Controller
    • Week View Controller
    • Locations View Controller
    • Settings View Controller
    • What’s Next
  • 5 A Quick Recap
    • MVVM Architecture
    • Naming the View Model
  • 6 Time to Create a View Model
    • Creating the View Model
    • Creating the Public Interface
  • 7 Put the View Model to Work
    • Adding the View Model to the Day View Controller
    • Creating the View Model in the Root View Controller
    • Updating the Weather Data Container
    • Build and Run
  • 8 Rinse and Repeat
    • Creating the Week View View Model
    • Creating the View Model in the Root View Controller
    • Updating the Table View
  • 9 Using MVVM In the Settings View
    • Creating the Settings View Time View Model
    • Importing UIKit
    • Refactoring the Settings View Controller
    • Your Turn
  • 10 Adding Protocols to the Mix
    • Creating the Protocol
    • Conforming to the Protocol
    • Refactoring the Settings View Controller
  • 11 Making Table View Cells Autoconfigurable
    • Updating the Settings Table View Cell
    • Updating the Settings View Controller
    • Protocol-Oriented Programming
    • Conclusion
  • 12 Supercharging MVVM With Protocols
    • Creating a New View Model
    • Refactoring the Week View View Model
    • Creating Another Protocol
    • Updating the Weather Day Table View Cell
    • Updating the Week View Controller
  • 13 Ready, Set, Test
    • Adding a Unit Test Target
    • Organizing the Unit Test Target
  • 14 Testing Your First View Model
    • Creating a Test Case
    • Importing the Cloudy Module
    • Writing a Unit Test
    • Writing More Unit Tests
    • Resetting State
    • Unit Testing the Other View Models
  • 15 Using Stubs for Better Unit Tests
    • Adding Stub Data
    • Loading Stub Data
    • Unit Testing the Day View View Model
  • 16 A Few More Unit Tests
    • Unit Testing the Week View View Model
    • Unit Testing the Weather Day View View Model
  • 17 Taking MVVM to the Next Level
  • 18 What Are the Options
  • 19 DIY Bindings
    • Creating the View Model
    • Implementing the View Model
    • Performing Geocoding Requests
    • Notifying the View Controller
    • Refactoring the Add Location View Controller
    • Updating the User Interface
    • More Refactoring
  • 20 Why RxSwift
    • It’s a Library
    • Testability
    • Powerful
  • 21 Integrating RxSwift and RxCocoa
    • Defining Dependencies
    • Installing Dependencies
  • 22 Refactoring the View Model
    • Refactoring the View Model
    • Reducing State
  • 23 Refactoring the View Controller
    • What Have We Accomplished
  • 24 Protocol Oriented Programming and Dependency Injection
    • A Plan of Action
    • Defining the Protocol
    • Adopting the Protocol
    • Refactoring the Add Location View View Model
    • Refactoring the Add Location View Controller
  • 25 Testing and Mocking
    • Setting Up the Environment
    • Mocking the Location Service
    • Writing Unit Tests
  • 26 Where to Go From Here
    • Putting the View Controllers On a Diet
    • Introducing View Models
    • Improved Testability
    • More Flexibility
    • Where to Start

Authors have earned$8,182,613writing, publishing and selling on Leanpub,
earning 80% royalties while saving up to 25 million pounds of CO2 and up to 46,000 trees.

Learn more about writing on Leanpub

The Leanpub 45-day 100% Happiness Guarantee

Within 45 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

See full terms

Free Updates. Free App. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers), EPUB (for phones and tablets), MOBI (for Kindle) and in the free Leanpub App (for Mac, Windows, iOS and Android). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses! Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks. Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. It really is that easy.

Learn more about writing on Leanpub