Mobility

10 tips for building reactive mobile applications

Follow these best practices to ensure your mobile apps are as nimble and useful as possible.

istock-476085510.jpg
Image: iStock/solarseven

As mobile apps continue to evolve, the capability for them to operate in a reactive fashion becomes critical for ensuring engaging mobile user experiences.

What does the term "reactive" signify? It refers to an app with a set of standard behaviors that respond to the user's needs and actions. Examples include instantly reflecting changes in the user interface, synchronizing information across devices based upon user engagement (such as scheduling, notification, ongoing data updates, etc.) and pushing app updates from servers to devices to ensure the latest features are available for the user.

Let's look at some best practices for building reactive apps in today's demanding mobile environment. Note that certain elements such as security (the use of encryption to store or transmit private data for instance) should always be baked into any quality app, but since these elements don't apply within the context of reactive apps, I'll relegate them to the "you should be doing this by default" bin.

1. Ensure you have the right programming infrastructure

A reactive mobile app depends on the latest and greatest in programming advances. Make sure you've selected the best tool for the job. One such example you should consider learning and using is Apple's Swift programming language.

Dzone.com touts Swift as "the programming language of the future... built on a modern compiler infrastructure that provides developers with the ability to write more reliable code right from the start from Apple." It's open source (users are encouraged to contribute to the public source code) and can produce fast and robust applications. While it's presented as an app builder for iOS, Mac, Apple TV, and Apple Watch, Apple states: "We're providing binaries for OS X and Linux that can compile code for iOS, OS X, watchOS, tvOS, and Linux."

SEE: Apple's Swift programming language: The smart person's guide

2. Build a layout of the app to plan functions

Map out everything the app should do before you get started writing code; functions, features, errors, and all aspects of user interaction. Create a flowchart, which should serve as a table of contents to define successful app operation, and refer to this when building out the code and testing the results.

3. Ensure the app experience is seamless across all platforms where applicable

Not every app is intended to be run on an array of operating systems and devices. Some simple iOS or Android apps are merely intended for that platform. More elaborate and ambitious apps intended for a larger audience should be designed for all operating systems and devices, factoring in differences in hardware such as CPU/memory and whether users user a touch screen or keys to interact with the app. Apps which exist for desktops and mobile devices may not have all the same features since smaller screen sizes can be a limiting factor, so these disparities should be mapped out and defined, then documented for the user.

4. Leave out the kitchen sink

The most powerful and popular apps are the ones that serve a very specific function and stay entirely within those boundaries. Apps which attempt to perform numerous functions (some of which may be unnecessary or unwanted) often become too convoluted, confusing and cumbersome. An app shouldn't be all things for all people; such a concept is a recipe for failure. Focus on your intended user base to keep the app functions relevant to their objectives.

5. Plan for offline capabilities

Any mobile app which requires constant network connectivity is doomed. If a user needs your app to do their work but it requires a network signal they'll end up frustrated and dissatisfied — whether they're off the grid, on a plane, traveling or in an area with poor connectivity. Using a local NoSQL database as I wrote about last year, or some other form of a local data store can help ensure offline functionality remains robust and reliable.

One example is the help file. A help file in an app which simply links to articles on a website is only as good as the network signal the device possesses. It's tempting to centralize information in this way to create a single repository for data, but a better option is to build replication of this data to the mobile app so it will be available offline, and changes can be synchronized automatically when the device is online.

6. User feedback is key

Make sure your app allows user feedback, whether through reviews via an app store, by contacting an email address or social media account, or within the program itself. Monitor what users have to say about your app and respond accordingly to ensure you can support their needs and the app is best suited for their objectives as you develop updates or new features. Remember the concept "all feedback is good feedback" - whether positive or negative.

I spoke with Paul Kopacki, chief marketing officer at Realm, a mobile database that powers over one billion mobile applications and enables faster development of apps. He provided some further tips for developing reactive mobile apps.

7. Focus on the immediate UI components

The user interface should be as clean and clutter-free as possible. Ideal interfaces have one standard menu or toolbar for accessing all necessary functions to avoid having to backtrack or shift through multiple screens. Reduce the number of clicks or taps a user must engage in to navigate through the app. Provide shortcuts or easy access where available, especially to commonly-used functions.

8. Enable device-synchronization capabilities

Users may operate the app across numerous devices they own, so synchronizing data and app functions among these devices can be an enormous boon. The app should be able to track changes and handle conflicts (such as simultaneous edits of the same data), and replicate the changes in a bidirectional (or multidirectional) fashion. Avoid asynchronous networking (data being sent at different speeds) as that may result in lags or delays.

9. Use data bindings for a better flow of information management

Data bindings are another way to ensure the data is represented accurately. As Microsoft states, "data binding is the process that establishes a connection between the application UI and business logic. If the binding has the correct settings and the data provides the proper notifications, then, when the data changes its value, the elements that are bound to the data reflect changes automatically. Data binding can also mean that if an outer representation of the data in an element changes, then the underlying data can be automatically updated to reflect the change.

For example, if the user edits the value in a TextBox element, the underlying data value is automatically updated to reflect that change. A typical use of data binding is to place server or local configuration data into forms or other UI controls."

10. Build server-push features to communicate with the mobile app

Event-based push notifications from servers to mobile devices can be handy for sending alerts, details, status updates and other information beneficial to the user. Align the context accordingly. For instance, a maintenance notice sent a month early will likely be forgotten by the time comes. It's better to let users know the same week that the service will be down from midnight to two a.m. on Friday.

Conclusion

Using these tips can ensure your users (or customers) get the best possible results from your mobile apps. In my next article I'll talk about how best to build a workflow for updating mobile apps and focus on Apple's Swift programming language for a closer view.

Also see

About Scott Matteson

Scott Matteson is a senior systems administrator and freelance technical writer who also performs consulting work for small organizations. He resides in the Greater Boston area with his wife and three children.

Editor's Picks

Free Newsletters, In your Inbox