Breaking the monolith: Scalable Native Apps II (iOS implementation)

In this post, I will continue where I left off on part one “Breaking the monolith: scalable native apps,” by giving examples of how large projects can be decomposed to allow faster iterations. I will try my best to keep the technical jargon to manageable levels so that the concept is not lost (if you are not a developer familiar with some of the tools mentioned here).

Before we get started, here are a list of things that are recommended (but not required) to make the best of this piece:

  1. Basic knowledge of CocoaPods
  2. Xcode for iOS and Android Studio for Android
    1. For android, you will also need to setup a maven/Artifactory server
  3. A source code management system, such as GitHub or BitBucket

iOS sources can be downloaded here:

  1. Main application
  2. Order processing module

To simplest approach to modularizing an iOS application is to create a Podfile and integrate CocoaPods. From that podfile, a list of frameworks or libraries can then be listed as a dependency. CocoaPod will handle the dirty work of downloading these dependencies and making them available for the build. In our CookR.io example our podfile is pretty simple (integrating only the order processing module) but can be used to integrate any number of open source projects available on the web.

Create and version the module

In the attached sources, the first step was to create the module (private specs repo in CocoaPod parlance) with pod lib create Cookr.io.OrderProcessing. This starts a wizard that creates a new Xcode workspace with your module and optionally tests and an example project that may be used to functionally test your code. At the end a .podspec file is generated, this file is then tweaked to specify the version we are creating as well as any source files or resources that must be bundled into our framework.

Screen Shot 2017-04-23 at 10.58.30 AM

To keep things short and spicy, the order processing module merely defines one storyboard and a two view controllers. The first controller allows a user to choose the global flavour to apply to their meal. The second controller simply shows an image and the allows the user to end the flow (Done navigation button) and send the selected flavour back to the flow initiator.  This seems awfully simple, but it is a powerful feature of this architectural pattern.  In this example the initiator is the main application. However, this flow could be invoked from *anywhere* including another module!

Screen Shot 2017-04-23 at 11.01.33 AM

With a module defined, and published as per instructions in the CocoaPods guide for creating private specs repos, our main application can then consume this module without knowing the intricate details of how it is actually implemented. To do this, we create a Podfile in the application project (pod init) and list our module as a pod. Then run pod update to install the module and make it available to the project.

 

Screen Shot 2017-04-23 at 11.07.49 AM

Use the module APIs & Initiate the flow

With the above step complete, we can now get to the fun parts – using APIs exposed by the module. In our CookR.io example, this means invoking our OrderFlowIntitator factory:

import CookROrderProcessing
// ...
// Create a flow controller and present it - this hands control over to the
// the module
if let flowController = OrderFlowInitiator.flowController(with:nil) {
    self.present(flowController, animated:true)
}

This block of code hands the presentation and business logic/flow over to the module. Easy right? Now, there are some caveats that must be handled when building in the manner. The first one, is that module authors should keep the external interfaces very simple so that the consumer does not have to deal with messy details such as how to correctly load the storyboard(s) and controllers that the module defines. Afterall, we are striving for better decoupling! The second is that an application can have many frameworks and resource bundles. If the module uses resource bundles and storyboards, then care must be taken to load from the correct locations:

open class OrderFlowInitiator: FlowInitiator {
   // factory method for instantiating a flow controller
   public class func flowController(with parameters: Dictionary<String, Any>?) -> UIViewController? {
     return OrderFlowInitiator().create(with:parameters)
   }
 
  // internal implementation that conforms to the flow initiator protocol
  // ideally FlowInitiator would be a public protocol that can be shared across multiple modules.
  // for the purpose of this example, declaring it inside this module is sufficient
  func create(with data: Dictionary<String, Any>? = nil) -> UIViewController? {
     print("OrderFlowInitiator: start flow")
 
     // get the framework bundle that this class belongs to
     let frameworkBundle = Bundle(for: OrderFlowInitiator.self)
 
     // use framework bundle to lookup the resource bundle that our module's resources will be 
     // packaged in (see the s.resource_bundles mapping in podspec)
     let bundlePath = frameworkBundle.path(forResource: "CookROrderProcessing", ofType: "bundle")
     let resourceBundle = Bundle(path: bundlePath!)

     // with the correct bundle, create a storyboard and return the initial controller
     return UIStoryboard(name: "OrderProcessing", bundle: resourceBundle).instantiateInitialViewController()
   }
}

This code specifically always returns the initial view controller of the storyboard. If the module defined multiple storyboards with different flows, then the appropriate logic would also have to be added to OrderFlowInitiator.flowController(with:) method to determine which board/controller to setup and return to the caller.

(Optional) Return data to the flow initiator

When the module has completed its flow, depending on requirements, data can be returned to the caller. There are a number of ways to do this – in CookR.io example, we simply post a notification that can be handled by the application:

@IBAction func completeOrderFlow(_ sender: Any) {
  print("Order flow complete!")
  self.navigationController?.dismiss(animated: true, completion: nil)
 
  // deliver the outcome of the flow back to whichever module (or main app) that initiated the flow
  var flowResult = Notification(name: Notification.Name(rawValue: "flow.result"))
  flowResult.object = self.selectedFlavour
  NotificationCenter.default.post(flowResult)
 }

 

DEMO

The next post in the series will explore how to accomplish the same pattern in android.

#TillNextTime

– Martello Jones

Breaking the monolith: scalable native apps

Building one-off apps that have a single focus (for example games, picture viewers or “ToDo” apps) is relatively easy because those apps can be designed, tested and implemented in a wholistic manner.  In other words, the product teams that build those apps have a very clear picture of what the end product will be. Banking or telecommunications self-serve apps on the other hand are often less clear or constantly evolving.  These apps are generally produced by large organizations with competing or conflicting  internal objectives, timelines and budgets – as a result, these apps (when built as monoliths) are delivered late to market because each feature that is owned by a sub-division of the company has to wait on one or more major pieces provided by other sub-divisions.

How can these apps get to market faster?

Simplify, decompose into reusable units and break dependencies – In other words, large apps can get to market faster by going back to the basics of software design. Let us use a simple example of a restaurant app… Let’s call it CookR.io. CookR.io is (fictitiously) an app that allows a customer to submit an order that gets prepared by a crowd-sourced chef… (Before I go any further, I would like to shamelessly ask that if any reader wishes to build this app, please credit back to this site for inspiration :-D, please and thank you!!!). The app must be available on Android & iOS and must be launched on the same date.

Implementing this is relatively straight forward. Build the app, ship it. How we build this app however, will determine how quickly we can iterate on its features in the future. The typical approach here would be to have a single project with all the logic embedded, maybe sorted by folder structure or package name.

Monolith.png

This approach works, but we can definitely break the app into discrete units.

Step 1: Create a core component that does the basic functionality

A good example is to create an application scaffold that provides the UI layout and interaction design. This scaffold will reference the components defined in step 2 by library version and also have any visual integration points that are required.

Step 2: Identify the discrete functions of the app

In CookR, this could include taking an order, sourcing a chef, providing status update via push notification or processing payments. These units would then be built as components/libraries that can be uniquely versioned, expanded upon or completely re-written at any given time without affecting the progress or delivery targets of the overall application. This also means, that each of these components can have their flows defined and implemented in total isolation. In the case of a large organization, this translates into a situation where separate sub-divisions can quickly meet their own objectives and deliverables without affecting other teams, unless of course they have a hard dependency on a specific version of another component.

Step 3: Integrate each component

With steps one and two out of the way, integrating the components will be a breeze. The only requirement here, is that the core application scaffold defined in step 1 creates visual entry points (buttons, links etc.) that will trigger calls into the components. The components can then take over and deliver the experience that is defined in that component.

Our decomposed application now looks like this:

Componentized.png

As you will see above, the overall application is now less brittle to changes because stable versions of the components (libraries) can be referenced by specific iterations. Departments are then free to re-use, re-create or otherwise augment the functionality provided by these libraries at will. In our example, if the organization decides that the application needs to go to market with a Chef Sourcing functionality that has Facebook integration on March 9… This structure allows all the team to build this entire flow in Chef Sourcing 2.4.1 without affecting any existing code that depends on 2.4.0. The improvements can be unit and functional tested independently without a single code merge request until required (lets say march 7 for example). In practice, the date may not be so close, but the key thing here is that on March 7, depending on the UI design for Facebook integration this feature could be delivered to market with zero code changes to the application, since code changes were only done in the Chef Sourcing library that is consumed by the core application! Neat right?

Of course, this doesn’t account for crazy scheduling or other factors but this approach to mobile application structure opens up a world of possibilities for cross functional team collaboration and faster application delivery.

This is the high level concept… Next week I will use the CookR.io example to illustrate how this can be done on both iOS and Android…

#UntilThenCodeTight #HappyMonday

-Martello Jones