Motoblur & Android Fragmentation: The Follow-Up

Yesterday, I blogged about Motorola’s Motoblur UI, which adds an additional SDK for its specific APIs beyond the standard Android stacks. I reckoned that this might mean more fragmentation, which would push it a step closer to the nightmare that was/is J2ME.

I received two quick reactions to this: one reader commented that this was only bad if you wouldn’t have good tools and compilers. To him (@tederf), I would respond that, while it is certainly true that good tools reduce the friction, raise efficiencies and alleviate overall pain, the smallest common denominator is always just that. In my previous companies, we used to produce up to seven or eight different J2ME builds in order to maximise performance of our games on the huge spread of handsets. Could we have done with one build? Probably. Would the result have been great? Almost certainly not!

Anyway, the more interesting reaction came from the good folks at Motorola themselves. They reckoned (via Twitter; they are @motoblur) that:

with all due respect, I feel you’ve misunderstood motoblur, and android fragmentation concerns are a wee bit overblown.

Now, now. I offered them a guest post here in order to explain this further. I have unfortunately not yet had a response (which I take, applying Twitter attention spans, as lasting silence). But I still wanted to use the opportunity to elaborate a little more on this (and, no, I will not lament Moto’s lost opportunity to feature their wares on this humble site).

To clarify a couple of things outright:

  1. I would be delighted would I be mistaken (and note that I am not a techie, so this is a distinct possibility!).
  2. I would be equally delighted would Motorola manage to regain some of its lost ground. The world clearly would be a better place with another strong manufacturer regaining old strengths (although maybe with better UI this time around – which Motoblur certainly seems to offer [see picture on the right of the Motorola CLIQ!).

But let’s go back to the general issue of Android fragmentation threats (the fact that I pointed this out – again – en cas de Moto is of course purely coincidental).

So let’s dive in: with open source software, there is always the intrinsic possibility that fragmentation will occur. Why do people customize it? Because they can! vendors, developers and operators that make up the Open Handset Alliance (which releases Android) can tweak is in whichever way they like (or “need” to) and for any number of reasons: to protect IP, to optimize performance on their network or for certain devices or simply because they feel they need some distinguishing factors, some degree of uniqueness. The result can be, however, as one analyst puts it that

there will be multiple flavors of Android, all of them incompatible with each other. That, in turn, necessitates different versions of each application or updates to accommodate the entire device ecosystem. On the whole, such activity negates the cost efficiencies inherent in the idea of a standard, open operating system, and potentially makes the Android Market a confusing place to shop for widgets.

And that’s what you call fragmentation. Interestingly, there were rumours that Google had made the Open Handset Alliance members sign “non-fragmentation agreements” but it seems that this is either not true or not enforceable.

Others point out that HTC, Samsung, Dell, Verizon, (may I add Motorola?) all have phones on the way that run on different software to the others. Reports of version conflicts, lack of backward compatibility, etc, etc. I mean, hell, there is even an “alternative” Android app store (with 223 apps as of tonight)… Sounds familiar?

Dear Motoblur, if it is different with your SDK, please enlighten us! I am sure I will not be the only one applauding!

Image Credit: http://www.visionmobile.com

Previous

Carnival of the Mobilists # 195

Next

[OFF TOPIC] #BAD09: Blog Action Day on Climate Change

6 Comments

  1. I'm with you, I think this is the first act for an android fragmentation scenario. I experienced the nightmare in the j2me development and I recall when Nokia introduced its advanced APIs (the nokia ui apis) hailed as a really good thing, motorola introduced its too and Siemens and so on. This plus the dozen of screen sizes, memory capacity etc, turned the j2me development in a nightmare.
    Looks like androind is going in the same direction.

  2. This direction in which Android is going is the very direction that Symbian tried to walk away from – Symbian UIQ, Symbian S60, and Symbian S80. This time, it looks like it is going to be worse.

    We'll see how it all turn out.

  3. I think that the problem isn't so big as it was some years ago with j2me. The main reason fragmentation was a problem then (and still is, but a little less now), is that the devices, their software/OS and the J2ME specification were very “weak”, not powerful at all. If you wanted to write some interesting application you had to take care that it would work with the quirks of each mobile device, prepare it for very strange screen sizes (why 130×130 if the standard was 128×128? why 176×204 and 176×205 from the same manufacturer?). Or if you wanted to write something as “basic” as an SMS sending application, you had to watch out for non-compatible devices, problems with the JSR implementation, etc.. But as devices, OS and the platform as a whole mature, this problems appear less and less. Look at the PC world, where game developers make a videogame that works on a huge variety & combination of different hardware.
    My point is: If the platform is more powerful, you can make the application auto adapt to it and the additional performance and development cost of doing that will get lower and lower as time passes. E.g.: The cost of adapting from 128×128 to 176×204 is bigger than from 240×320 to 320×480, because 128×128 was itself a nightmare to work with. I don't know if Android phones have reached the point where that cost is small enough to not be a problem at all, but if not, the time that will happen is not that far.

  4. Thanks for this very insightful comment, Sebastian. I agree that it doesn't look as bleak as it was with J2ME. My concern is that carriers may feel compelled to add more and more “customized” tweaks to “their” Android. So: Android per se would indeed not appear to being as problematic as J2ME might have been. But Android + carrier SDKs very well might.

    And again: I hope I am wrong!

  5. I think that the problem isn't so big as it was some years ago with j2me. The main reason fragmentation was a problem then (and still is, but a little less now), is that the devices, their software/OS and the J2ME specification were very “weak”, not powerful at all. If you wanted to write some interesting application you had to take care that it would work with the quirks of each mobile device, prepare it for very strange screen sizes (why 130×130 if the standard was 128×128? why 176×204 and 176×205 from the same manufacturer?). Or if you wanted to write something as “basic” as an SMS sending application, you had to watch out for non-compatible devices, problems with the JSR implementation, etc.. But as devices, OS and the platform as a whole mature, this problems appear less and less. Look at the PC world, where game developers make a videogame that works on a huge variety & combination of different hardware.
    My point is: If the platform is more powerful, you can make the application auto adapt to it and the additional performance and development cost of doing that will get lower and lower as time passes. E.g.: The cost of adapting from 128×128 to 176×204 is bigger than from 240×320 to 320×480, because 128×128 was itself a nightmare to work with. I don't know if Android phones have reached the point where that cost is small enough to not be a problem at all, but if not, the time that will happen is not that far.

  6. Thanks for this very insightful comment, Sebastian. I agree that it doesn't look as bleak as it was with J2ME. My concern is that carriers may feel compelled to add more and more “customized” tweaks to “their” Android. So: Android per se would indeed not appear to being as problematic as J2ME might have been. But Android + carrier SDKs very well might.

    And again: I hope I am wrong!

Powered by WordPress & Theme by Anders Norén