Eidhof Chris - App Architecture

Chris Eidhof

Matt Gallagher

Florian Kugler

objc.io

This book is about application architecture: the structures and tools used to bring smaller components together to form an application. Architecture is an important topic in app development since apps typically integrate a large number of diverse components: user events, network services, file services, audio services, graphics and windowing services, and more. Integrating these components while ensuring state and state changes are reliably and correctly propagated between them requires a strong set of rules about how the components should interoperate.

Sets of repeatedly applied design rules are called design patterns, and in this book, we will present an application thats fully implemented in five major application design patterns, which range from well established to experimental. These are:

• Model-View-Controller (MVC)
• Model-View-ViewModel+Coordinator (MVVM-C)
• Model-View-Controller+ViewState (MVC+VS)
• ModelAdapter-ViewBinder (MAVB)
• The Elm Architecture (TEA)

The abstract block diagrams commonly used to describe application design patterns at the highest level do little to describe how these patterns are applied to iOS applications. To see what the patterns are like in practice, well take a detailed look at typical program flows in each of them.

Well also look at a range of different patterns to show that there is no single best approach for writing programs. Any of the patterns could be the best choice depending upon the goals, desires, and constraints of you, your program, and your team. Application design patterns are not just a set of technical tools; they are also a set of aesthetic and social tools that communicate your application to you and to other readers of your code. As such, the best pattern is often the one that speaks most clearly to you.

After presenting each implementation, well spend some time discussing both the benefits each pattern offers for solving problems and how similar approaches can be used to solve problems in any pattern. As an example, reducers, reactive programming, interface decoupling, state enums, and multi-model abstractions are techniques often associated with specific patterns, but in this book, after we look at how these techniques are used within their patterns, we will also look at how their central ideas can solve problems across different patterns.

As this book will demonstrate, application architecture is a topic with multiple solutions to every problem. When properly implemented, all the solutions give the end user the same result. This means that ultimately, application architecture is about making choices to satisfy ourselves as programmers. We do this by asking questions such as what problems we want solved implicitly, what problems we want to consider on a case-by-case basis, where we need freedom, where we need consistency, where we want abstraction, where we want simplicity.

In this book, we show five different implementations of a single application: the Recordings app (the full source code of all implementations is available on GitHub). As the name might suggest, its an app that records and plays voice notes. It also allows us to organize the recordings in a folder hierarchy. The app features a navigation stack of folder view controllers (for organizing files), a play view controller (for playing files), a modal record view controller presentation (for recording new files), and text alert controllers (for naming folders and recordings). All content is presented in a standard UIKit master-detail interface (the folder view controllers appear in the primary pane, and the play view controller appears in the secondary pane).

When choosing the sample app for this book, we made a list of criteria, and the Recordings app fulfills all of them. It is complex enough to show architectural patterns, yet simple enough to fit in a book. There is a nested navigation hierarchy. The app contains views with real-time updates, rather than just static views. The model is implemented as a persistent store that automatically saves each change to disk. We have two versions of the app that include networking. Our app works on both iPhone and iPad. Finally, we support state restoration.

Had we chosen a smaller app, it might have been easier to understand, but there would have been fewer opportunities to show differences between architectures. Had we chosen a larger app, the scalability of different architectural choices would have been more apparent, but the details would have been harder to see. We believe the Recordings app finds a good balance between these two extremes.

The app starts by showing a folder view controller for the root folder. The folder view controller is presented in a navigation controller in the primary pane of a split view controller. On the iPhone, this primary pane is presented in full-screen mode, and on an iPad, it is presented on the left side of the screen (this is standard behavior of a UISplitViewController on iOS).

A folder can contain both recordings and nested folders. The folder view controller lets us add new folders and recordings and delete existing items.

Adding a folder brings up a modal alert view that asks for the folder name, and adding a recording immediately presents the record view controller modally.

When selecting an item in the folder view controller, the navigation action depends on the type of item: if we select a folder, a nested folder view controller is pushed onto the navigation stack, and if we select a recording, a play view controller is pushed onto the navigation stack.

The play view controller contains a text field used for both displaying and changing the name. It also contains a slider for the current play progress: as were playing, the slider changes, and when we move the slider, the playback continues at the chosen position. Above the slider are labels for the current play position and total duration. Finally, the play view controller contains a button to start, pause, and resume playback.

We have recorded videos that go together with the book, and they are available as a separate purchase. The videos focus on topics that are best presented in a live coding and discussion format, such as:

• Building a new feature in each of the five versions of the Recordings app (a mini player).
• Building a very small app from scratch in eight different design patterns to highlight their commonalities and differences.
• Implementing a small version of the TEA framework.

We hope these videos will give you an even better idea of the practical implications of each of the application design patterns covered in this book.