Email the Author

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

@_bartjacobs

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 Twitter. Follow me and say hi. You can also follow Cocoacasts on Twitter if you’re interested in what I teach on Cocoacasts.