Four Things to Make Your Mobile Solution Better

If you’re in the business of authoring complex enterprise mobile solutions, then application performance, user interface familiarity, and overall stability are at the top of your client’s list of must-haves. The following are four things that you can incorporate into your daily coding routines to achieve the results your clients are looking for.

Do your heavy lifting on the desktop side

Mobile devices, as powerful as they have become, still possess limited resources. Because of this, developers usually have to take special precautions to maintain application performance.

One way to accomplish this is to identify areas in your client source code that produce read-only datasets from “data munging” and that could just as easily be performed in server source code on a desktop PC. If one or more areas are found, move them to the desktop and take advantage of the additional resources that reside there. All that would need to be downloaded now is the resulting read-only datasets, thus reducing your data footprint and time to access the results.

Normalize, refactor & reuse

Redundancy in mobile software applications, whether it’s in application data or actual source code, is at the top of the list of things that foster bugs, performance issues, and application bloat. You can reduce these problems in your mobile apps by simplifying the data and creating reusable chunks of code through either object-orientated methods or general purpose APIs.

As examples, normalizing redundant, read-only data before it makes it to the mobile device reduces your data footprint, the time to download it, and the time to look it up. Reviewing your source code ensures that it is being developed to specification. Reusing it through good object-orientated design promotes application stability and performance, and also simplifies debugging. Refactoring it keeps it clean, readable, and compact. Normalizing it reduces the chances for bugs and performance issues to occur.

A basic rule of thumb is, as long as proposed changes clearly improve the overall performance and code readability of the application without negatively affecting the overall design or end-user experience, then it’s probably a good thing to do.

Separate the business logic from device-specific layers

Separating complex business logic and state machine management from any actual interaction with system layers helps to promote code readability and portability. To do this, add a layer of abstraction in your design that encapsulates the system level calls and separates them from the actual business logic. Then make use of the new layer in the business logic by calling it instead of the system level routines.

When it comes to supporting multiple mobile platforms, this technique will be critical to your success. In fact, if done properly, all that you will likely need to change is the implementation of your abstraction layer when you make the move to another platform. Of course, choosing a common programming language that exists across all target platforms will also dramatically simplify the port. Be sure to check this out before you start coding.

Learn the job

For enterprise mobility developers, translating a client’s business process into a usable mobile solution can be quite a challenging task. In some cases, the development team may already know the type of business the client is in. Other times they may be particularly skilled in a component needed for the overall solution but not all that familiar with how the client anticipates to use it.

One valuable technique to address these concerns is to designate one developer to be in charge of learning the client’s business process inside and out. Ultimately, this would entail visits to the client in order to witness the business process first-hand. Developers should be willing to immerse themselves in all aspects of the job, documenting the subtle points and properly assessing work flow.