This work describes a solution to a costly problem that surfaces in software product engineering on Objective C technology stack. Particularly, it emerges when designing a software product targeting both OS X and iOS where a significant part of the functionality is common for both platforms. This brings in the question of how much code can be reused between the two implementations. A multitude of concerns need to be probed and the solution domain can easily be a victim of combinatorial explosion. Like in many other cases, analysis in terms of design patterns can put things in perspective. Both Cocoa and Cocoa Touch (standard frameworks for application development in OS X and iOS respectively) highly encourage embracement of MVC as a design pattern. It is even a necessity for utilizing certain parts of the two frameworks. Therefore, it is wise to keep our solution inside the MVC design paradigm. Our exploration to the solution starts with a close examination of MVC and the role played by each component in the design pattern. Controllers in both Cocoa and Cocoa Touch are responsible for managing views and responding to user actions, embracing Strategy pattern. They are tightly bound to the views they control and therefore are hardly useful outside the context of that particular view. At the same time views and controllers in OS X (based on NSView and NSViewController respectively) are disparate from views and controllers in iOS (based on UIView and UIViewController respectively). This is mostly due to differences between the two platforms. It inevitably confines cross-platform reusable space to model classes. On the other hand, it is not very unlikely to have certain views in the product that are supposed to appear and respond to user events in similar ways in the two platforms. Failure to exploit this cleverly in the architecture can lead to code replication causing less maintainability. It will also disrupt the homogeneity in user interface semantics of the application between the two platforms. Thereby strict adherence to traditional MVC hinders the architect from harnessing the power of this domain artifact.

1. Adapting View Models as a Means For
Sharing User Interface Code Between OS X
and iOS
Dileepa Jayathilake
SATURN 2013

2. Background
Problem Identification
Solution Overview
Implementation
Discussion
Conclusion

3. Product for both OS
X and iOS
With a significant
part in common
How to reuse code
maximally?

5. Is it possible to
share UI code?

7. View Models
implement
common part
of UI
View Models
are shared
View hooks into
View Model
Controllers
hold platform
specifics
Bidirectional
bindings are
platform-specific

8. View Models contain view data and common UI behavior
Models are exposed to Views through View Models
1
2

9. Common &
Platform-specific
components of the
solution

10. Proof of
Concept:
Book Store
Application

11. Use of the solution in Book Store
application

12. Advantages
• Improved code reuse
• Better readability
• Better Separation of
View Logic
• Enhanced testability
Concerns
• Framework class usage
• Bi-directional bindings

13. CONCLUSION
View Models combined with traditional
MVC can improve code reuse
significantly while providing other
advantages for applications targeting
both OS X and iOS.

14. QUESTIONS