Mobility is so ubiquitous that it is almost not even a separate thing anymore. This creates a challenge for enterprises that offer BYOD mobile devices and corporate data access. How do you enable the mobile workforce with enterprise applications? One way is to roll your own mobile application to get the necessary data into the mobile user’s hands. I have had some experience with this and wanted to ponder some self-proclaimed theorems which are outlined below.
Theorem #1
Mobile applications developed for native devices with native code are superior.
The following is an example of what you might need to build native mobile applications for various mobile devices:
| Platform | Development Framework | Language | IDE |
|---|---|---|---|
| iOS | iOS SDK | Objective-C | Cocoa, Xcode |
| Android | Android SDK, Android NDK | Java, C/C++ | Eclipse, NetBeans, IntelliJ IDEA |
| Windows Phone | .NET | C# and others | Visual Studio |
| Window 8 Metro Style Apps | WinRT | C++ / C# / VB.NET / Javascript | Visual Studio |
| Blackberry | Java ME + Optional Packages + API extensions | Java | Eclipse |
| ChromeOS | Webkit | HTML / CSS / Javascript | Many |
Unfortunately, BYOD makes Theorem #1 hard. If you are going to go the native code route, you have to maintain a separate code base (with separate IDE’s) for all possible devices your users will bring in. There are some other frameworks that I’ll talk about in another article that help with this, but there is always a tradeoff.
Theorem #2
Apps that Look Better are Perceived to be Better.
Looks matter. Period. If you give an application to a user that has limited functionality but looks sexy, that application will be perceived as better than an application that has more functionality but is ugly. You know it’s true.
Therefore, do yourself a favor and use a framework like one of the following:
These frameworks make it easy to make it look like you know what you are doing (at lease design-wise)
Theorem #3
Inverse Proportions are Everywhere.
There is always a tradeoff somewhere. Referencing the picture above, think about painting a room. I can paint a room with a paintbrush and not waste too much paint. However, to speed things up, I use a paint roller and waste more paint. Therefore, the ease/speed in which I paint a room is inversely proportional to how much paint I waste.
The same thing is true for security. If everyone in the world had a public IP address with wide open ports, things would be pretty easy if there were not bad guys/girls out here. In the real world, there are bad guys/girls out there, so we have to attempt to keep them out. The security measures can be a burden on the user. Therefore, security is inversely proportional to usability.
That last picture up there is the icon for PhoneGap. PhoneGap is one of many frameworks that attempt to make Theorem #1 easier. You can read an introduction to PhoneGap here.
There, of course, is a tradeoff. Building mobile apps with abstraction layers like PhoneGap introduce translation. You may not have access to all mobile device features immediately, there can be a performance tax, and apps will tend to be bigger. Not all mobile frameworks are created equal and I will talk about some pros and cons of different frameworks (like Xamarin, Citrix Mobile SDK for Windows Apps, Intel XDK, etc.) in a separate article.
Wrapping Up
So, there you have it. My self-proclaimed theorems for mobile app development. Agree? Disagree? Or, have something else to add? Just leave a comment below.