Mobile Development Models

With the release of the iPhone, there has been much hemming and hawing over whether the Web development model is sufficient for mobile devices. Many people have claimed that the iPhone needs to be a truly open platform with a native SDK (hey, it's got OS X, right?), but what would be the real implications of that?

The current spectrum of mobile development platforms looks something like this:
1. Web-like development (e.g. iPhone)
2. J2ME development
3. "Native" development frameworks (Symbian, Windows Mobile, Blackberry, Sidekick)

At the far end, basic web development models (including WAP) allow for very limited interactivity and a minimal graphical experience. More advanced web development models such as those supported on high-end handsets like the iPhone (Ajax, Flash, etc.) support better interactivity, but don't really allow access to advanced features of the device, though with the appropriate Javascript libraries this may change. A number of widget platforms follow a similar model, taking some combination of markup and scripting language outside of the browser.

J2ME allows for better interactivity than a pure web model, supporting offline usage and better graphics for games. J2ME also seems to have the problem that many of the JVM implementations are highly unstable, frequently crashing the device or failing to run applications correctly. J2ME does offer the promise of portability, though in practice there is still a lot of work in porting to account for variations in implementation of the core JVM.

Blackberry and Sidekick both have core development frameworks based on Java, but allow much better integration and fuller feature sets (threading, phone feature integration) than J2ME with its lumbering JSR process. These platforms' core applications are built on Java, so the JVMs are very stable and offer deep integration with the platform. Windows Mobile and Symbian offer native (or Java/.NET bindings) to much of the platforms' functionality.

The main categories of applications I see are:
1. Basic data-driven interactive applications (e.g. PIM)
2. Resource intensive interactive applications (e.g. games)
3. Deep phone integration; hardware interaction; advanced threading.

These categories aren't completely orthogonal, but suffice for this discussion. Given the platform choices listed previously, which of these applications are enabled?

Web development really only supports category #1. J2ME supports category #1 and #2. As more features are added through the JSRs, #3 becomes possible in J2ME though at present is not realistic. #3 will always be more feasible in the "native" models as the newest features are likely to take some trickle down into the other models.

Where does this leave us? I think for most applications, especially the typically data-driven applications built in today's connected world, the web model will suffices. As phones become more powerful (and thus more capable of running standards compliant browsers) I think we will see J2ME's current place being usurped by the Web model. Look for this to happen especially as offline frameworks such as Google Gears get ported to mobile.

Application category #3 is the hardest to describe, but also the most crucial to innovation in my opinion. As new features are added to mobile devices, these features are released first at the native level and then trickle down into the J2ME and web models. At present the things you might want to do at this level include background operations, file system access, control over Bluetooth or Wi-Fi, and access to signal strength. You're not going to get the same seamless experience from a web app as you can from a native app, though the web world is constantly closing the gap.

As Phil Bogle points out, Steve Jobs has seeded a lot of FUD around this issue, but Jobs also has a point - if users have to put up with crappy native apps taking over their devices, the experience will suffer. Apple has typically taken the road of releasing fewer features and keeping the user experience simple and consistent. For most users this is fully sufficient - it's only the geeks who want to install the latest and greatest (and potentially device exploding software) who are squawking about an "open" platform. These users are best off sticking with a development device such as OpenMoko.