Mobile development is tough. Anyone who has created an app, especially natively, will tell you that. While the tools and SDK’s have improved dramatically over the years, the fundamentals have stayed the same. What is it that makes it so tricky, and why does the lay person assume it’s so easy?
The start of the difficulties is the inconsistent nature of mobile devices. I’m not talking about specs and screen sizes in this case, I’m talking about where you are and what you’re doing. The beauty of programming for these devices is that they provide all kinds of sensors and measurements, as well as a variety of network connectivity methods for use in your apps. Unfortunately you have no way of knowing what the state of these sensors or data connections will be when a user fires up your app so additional logic must be added to handle a large number of scenarios. Data connections are transient and prone to failure. If your app relies entirely on a network connection, you’ll have a lot of mitigation to deal with that you wouldn’t normally have with a web application or desktop app.
And that’s just the tip of the iceberg. Apps can be shoved into the background at will. Limited storage space can dump your cache. Memory will fill up and leave no room for your software to run. Batteries dies, and so forth. Where desktops are sitting comfortably, plugged in to infinite power and a reliable internet connection, mobile phones are free wheeling through space, leaching sips of data and GPS when able while gradually marching toward battery death. It’s a hostile environment for software.
Then there is the issue of app design and layout across a number of screen sizes and orientations. In Androids case, the number of screen sizes is in the hundreds. When you’re constructing your user interface, great care must be taken to make sure your app works properly on all of your target devices. Tons of time consuming bugs will pop up during this process.
Along the same lines is operating system and SDK version fragmentation. As new and better versions of iOS and Android are released, your application faces greater challenges for supporting both new and old versions of the system. Things that work great in one version may work terribly in another, or not at all. Depending on your audience requirements, it can take significant effort to account for the differences. Android is extremely fragmented in both hardware and software versions. There are currently over 11,000 distinct Android devices out there and the OS mix is the most fragmented it has ever been.
Why then, in light of all of that, does the lay person assume mobile apps are easy to make? Because some shops have done it so well. Great mobile apps look effortless. You hardly even think about how you’re using them when they’re done at the highest level. They’re like an extension of you. This leads people to believe that every app should be that way, or at least their app that they hired a developer for should be. And they’re right. But when that person references a feature that they want in their app which should replicate Twitter, or Paper, or Instagram, remind them that those companies didn’t build their mobile applications on a $5,000 budget.