- Why Businesses Are Adopting Mobile Applications
- Driving Business Process Innovation
- A Formula for Designing Engaging Systems
- Unique Challenges for Development of Engaging Applications
- Enterprise Mobile Development
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Unique Challenges for Development of Engaging Applications
The creation of systems of interaction involves some unique requirements and challenges.
Most of the rest of this book provides an in-depth view of IBM’s recommendations for planning, developing, testing, and deploying mobile applications. Some of those recommendations are echoed in the following paragraphs, and you can refer to the later chapters for more details.
Form Factors and User Input Technology
The first and most obvious aspect of mobile applications is that the form factor for display and user interaction is significantly different from what is used by other forms of software. A smaller form factor means that the amount of data displayed to the end user, and layout of that data, needs to be tuned to the “real estate” available on the device. Significantly less data may be displayed on some devices and therefore it must be exactly the “right” data (most relevant to what the user needs at that point in the application). This variety in form factors motivates the “responsive design” approach for application presentation, where the same application takes advantage of the display resources available on the device where it is running.
Another obvious physical difference for mobile applications is that the mechanisms for user input are different. Mobile devices have pioneered the use of nonkeyboard “gestures” (e.g., touch, swipe, and pinch) as an effective and popular method of user input. Gestures must be planned for and supported for a satisfying mobile application user experience. In addition to tactile user input, mobile devices are a natural target for voice based user input. In fact, the traditional keyboard typing form of user input is probably the least effective and least popular mechanism for input to the new systems of interaction.
Besides gathering input directly from the end user, new systems of interaction have the capability to receive input from other sources such as geo-location from the GPS component of the device and image information from the camera typically built into the device. These forms of input make mobile apps more powerful and useful than applications with a more limited array of input possibilities, and they must be considered during mobile application design and development.
Usability and User Interaction Design
There are several reasons why usability and user interaction need greater attention in the design of mobile applications. The difference in form factors and user input methods is one. It is much more difficult and time consuming to plan how to display only the data that is precisely necessary than it is to simply display all possible data and let the user visually sift through it for what they want. The mobile app designer, by contrast, has to consider the screen real estate. When an application needs to present a broader scope of data with multiple layers of detail, it is usually better to use a progressive discovery approach that allows the user to “drill down” into incrementally greater levels of detail focused on fewer specific items.
The rich variety of input methods available on mobile devices is another reason that early design work must identify and leverage more efficient ways for input data to be delivered than the simple “just type it in a form” design, which is a default for traditional web and PC applications. Designers must avoid extensive keyboard typing for mobile apps in order to reduce end user frustration (with drastically smaller touch keyboards and lack of traditional typing feedback). Yet, identifying nonkeyboard ways in which information can be gathered and delivered to the mobile app is a significant design challenge.
In addition, there is still a more subtle reason for paying extra attention to the mobile app design effort. The way in which end users interact with mobile devices and the applications running on them is different from how they interact with stationary PCs (and even laptops). Mobile device users typically hold the device in their hand while also interacting with the immediate circumstances of their physical situation. Mobile users typically cannot concentrate on the mobile app for very long before switching attention to their physical surroundings. The interaction model for users of mobile apps is short, interrupted, and “bursty” (meaning that they need to complete the application task very quickly before switching attention).
All of these factors drive the need for applying user-centered design very early in the mobile app development project. Ideally these usability and design considerations should be codified in the requirements for the mobile application, and then linked to the later stage development deliverables, along with the tests that validate that the user interaction and “consume-ability” of the app is as satisfying as possible.
Choice of Implementation Technology
There is a spectrum of implementation choices for mobile applications on the market, and no one answer is perfect for all situations—each choice has its advantages and disadvantages. So the challenge for mobile development teams is to understand the trade-offs between the technologies, and make a choice based on the specific application requirements.
The choice of implementation technology for a mobile project impacts other decisions related to the application’s development, including:
- Limiting choices for development tools
- Team roles and structure
- How the application is tested and verified
- How the app is distributed and delivered to the end user
So, the choice of implementation approach for a mobile application is crucial, and this early stage decision needs to be made very carefully.
Native Application Implementation
A “native” implementation means you are writing the application using the programming language and programmatic interfaces exposed by the mobile operating system of a specific type of device. For instance, a native implementation for an iPhone will be written using the Objective-C language (or more recently the Swift programming language) and the iOS operating system APIs that Apple supplies and supports.
Native application implementation has the advantage of offering the highest fidelity with the mobile device. Because the APIs used are at a low level and are specific to the device for which the application is dedicated, the application can take full advantage of every feature and service exposed by that device.
However, native mobile app implementations are completely nonportable to any other mobile operating system—for example, a native Apple iOS app must be totally rewritten if it is to run on an Android device. That makes this native implementation a very costly way of producing a mobile business application.
Web Applications
Newer smart phones and tablets come with advanced web browsers preinstalled, and it is relatively easy to implement a standard web application with special style sheets to accommodate the mobile form factor and approximate the mobile device “look and feel.” Mobile applications implemented using this approach support the widest variety of mobile devices, since web browser support for JavaScript and HTML5 is fairly consistent. There are several commercial and open source libraries of Web 2.0 widgets that help with this approach. In addition, the web programming model for mobile application implementation has an advantage for enterprises that already have developers trained in the languages and techniques for web application development.
The disadvantage of pure web application implementation is that such apps have no access to functions/features that run directly on the mobile device, such as the camera, contact list, and so forth.
Hybrid Mobile Application Implementation
Hybrid mobile application implementation is a compromise between pure native implementation and pure web implementation. You write the mobile apps using industry standard web programming languages and techniques such as HTML5 and JavaScript, but you package the app into a natively installable format that is distributed via the app store mechanism.
Hybrid apps are linked with additional native libraries that allow the app to have access to native device features from the single application code base. Because the bulk of a hybrid application is implemented using device-agnostic technology, most of the code for the application is portable and reusable across many different mobile operating systems. However, small segments of native code can also be integrated with the hybrid app, which means that the developer can decide how much of the app implementation shares a common code base (using the web technology) and how much is device-specific customization (written in native code).
Mobile Application Build and Delivery
Because businesses want to deliver mobile applications into the market quickly, mobile development projects typically have extremely aggressive time lines. Inception-to-delivery time frames of a few months are common. The pressure to deliver mobile apps quickly results in the adoption of agile development methods for most mobile projects.
An important element in agile development practices is continuous integration and builds. Application changes that are delivered by developers need to be processed immediately for all of the mobile operating systems on which the application is required to execute. If the mobile application is a hybrid or native implementation, several different builds of the application need to be triggered each time a change set for the application is delivered by a developer. The build setup and configuration for each supported mobile environment will be different from the others, and it is most likely that a small “farm” of build servers will need to be provisioned and available to handle these builds of the mobile application for multiple operating systems.
Testing
Testing poses another huge challenge for mobile application development, because it represents a step-jump in complexity and cost over more traditional applications. Unlike traditional PC and Web applications, the range of potentially supported mobile devices and release levels is staggering. Test matrices for mobile projects commonly contain hundreds and even thousands of permutations of device, mobile OS level, network carrier, locale, and device orientation combinations.
There are more variables for mobile testing that are not relevant for other kinds of software. The same device model may function in a subtly different way when connected to a different carrier network. And the quality of the network connection can have profound impact on the behavior of a mobile application. Even the movement of the mobile device itself may be an important factor in the behavior of the application (some applications specifically exploit device movement).
The majority of mobile apps are based on multi-tier architecture, with the code running on the device itself serving as the “frontend” client to data, and the services supplied by more traditional middle-tier and data center representing the “backend.” Effective and comprehensive testing of mobile apps requires that all tiers of the application be addressed, not only the code on the mobile device. The setup and availability of test versions of the middle tier and backend services can present very large cost and complexity challenges for the testing of mobile applications.
Many mobile projects start by using manual testing approaches, which is the quickest way to begin testing. But you have to buy all of the various mobile devices that you plan to support with the app, and pay someone (likely a team of people) to tediously go through a written script of instructions describing the tests on each of those devices for every build of the application. While manual testing serves an important purpose in providing crucial usability feedback for the app, it is extremely expensive and inefficient.
As an alternative, there are mobile app testing solutions that rely on running an agent program on the device for interaction within an automated execution. This approach has the flexibility of using either real physical devices or emulators for testing, with the added efficiency of automation. However, the test team bears the costs of setting up the devices to be tested and installing the test agent on them.