Where are those mobile Qt apps ? (Part 3, Resolution)

After a short historical overview and a short list of growing pains, in this, third installment of the mobile Qt app story, I will focus on what boulders remain in the path of widespread adoption of Qt among app mobile developers. Most of the technical groundwork has been laid down, but to reach a final resolution, it needs to include a bit more than just a healthy base.


Decouple Qt releases from firmware releases

As seen from the infamous PR1.2 delay, a coupled-with-the-firmware release cycle is detrimental to the platform. If multiple devices are on the market, it would mean instant-fragmentation as developers would have to code for the Qt released with the last firmware. This is eating Android alive, too, as various handsets have different upgrade cycles. A separate distribution mechanism HAS to be employed. It will be tricky as with MeeGo and Symbian^4 Qt is part of the OS and many teams will be reluctant to bet firmware functionality on the backward compatibility of Qt. But that is not the only thing that can cause fragmentation if it isn't true that...

One mobile widget framework is enough


I harp about this regularly (and will continue to do so until I get good news from an official source :), the option to have separate widget frameworks for Symbian (Orbit/uiemo) and MeeGo (DirectUI/MeeGo Touch Framework) is something that is completely against what Qt is trying to accomplish by bridging the two OS-es. 

All you bases are belong to us

Qt is almost a country of it's own, addressing (or having a development version that addresses) various aspects of software development, both mobile and desktop. However, there is one thing where it is sorely lacking - the wizz-bang games department. Yes, QGraphicsView and 3D enablers are cool and all, but that is not enough (even with QML and UI scripting). It would certainly be an overkill and unnecessary delay to implement a complete game engine in Qt, but there are alternatives - make a Unity3D port, or, better yet, in the spirit of open source, sponsor Ogre binding (and GLES) development for Qt, with the necessary physics libs.

Build it and they will come - Ovi and devices

Professional mobile developers can and will materialize only after the market for the Qt apps materializes. The prerequisite for this is that Qt gets a first-class treatment in the Ovi store, and the QA process is not a hit-and-miss, something that developers are guessing about. Once the Ovi store really starts accepting Qt apps en masse, the question turns into how many devices can be targeted via Qt. I can hear you say "well that's like almost all Symbian handsets in the last 2-3 years". Yeah, but... 


Market share is not necessarily mindshare

Devices that can be retrofitted with Qt already exist in the (tens of) millions range. However, these devices are mostly low to midrange devices as there were no runaway Symbian successes in the high-end segment for a while now. It will be hard to convince people to target a market, no matter how objectively big if they believe/see it as a relic, which means... 

You've got to be cool

The vehicles for the Qt platform need to be cool and carriers of high tech. This is the wave Android is riding in 2010. Now, the best way to do this is having iconic devices (iPhone killers if you wish), but this is not ONLY about devices, it's about how you handle your technology in general, your devs, your community, blogs and everything related to it. Qt has to be perceived cool, a must-have even by non-tech people, not just a sticker on the corner of a box and something geeks nod over on irc. It IS the differentiating factor. Take for example the happenings of last week in the Nokia N900 land. A triple-release is done - preview of the Qt Web Runtime, a new version of Qt Mobility and the super-cool fcamera project. This triplet just oozes with tech-cool demo potential, but it just isn't leveraged, hardly getting even a blog post. Instead there is a campaign and an 'exciting news' about Ovi doing a comic (I'm sure it will be good, but... ). This points to comms issues, but also lack of

Communication/Community Focus

While I don't know how many different communities and aspects of Qt should there addressed separately, I'm pretty sure we are already overloaded, even before the hordes of the new Qt developer generations emerge. There is the Qt Developer Network, then we have Forum Nokia (home of the Nokia Qt SDK), followed by a more specific MeeGo community that is vested (well, at least the handset variant) in Qt, and the same will be true for Symbian. OTOH If you want to publish/talk about Qt development on currently available devices, you should go to maemo.org. While in community waters, we should also mention Qt Centre. Quite a handful of forums, mailing lists and irc channels to follow, and I have not even talked about communities focused squarely at end-users ! Speaking of end-users, some people who even knew about those Qt/fcam releases I mentioned above were quite discontent, because there is/was no concept of...

Control and drive expectations

The 'other' platforms and ecosystem have built up and trained users to expect certain things in a certain way, and if they are not educated, they will not understand what is going on and will easily dismiss even good news when it is not is a form they expect it in. See the above - new releases of QtMobility, WRT, etc were not treated by many as real news or support by Nokia for the N900, even though they were done by official Nokia teams. The concept of the 'holy firmware release' is still strong, because people don't understand the concept of libraries and components (as that is not how most other platforms operate).


Those would be my major points, and while they might sound a bit grim (some not even related to Qt itself), I don't think they are insurmountable at all, it just takes a little effort (some already underway) and presto, the arid Qt mobile app landscape can bloom like a savanna after a rain.

Where are those mobile Qt apps ? (Part 2, Adoption)

After my last blog post that discussed the Qt toolkit's history, present and future in the Nokia ecosystem, in this second part of my blog series I will talk about the problems of Qt adoption among developers so far and the effects these problems had on (the lack of) mobile Qt applications today.

This will not be an article about the flaws of C++, bloatedness of frameworks and similar issues. Sure, some people prefer other languages, other frameworks, or have a personal beef with Qt, but that is a different story. Here, I will talk about the WAY things happened, are happening and what could have been better handled - albeit from a Qt angle.


Are we there yet ?

Qt was originally a desktop application framework, but has been dabbling with embedded applications way before Nokia took over. However, the focus shifted dramatically and Qt (and derived technologies) went to overdrive, introducing new (and exciting !) technologies and approaches by the boatload (see MeeGo Touch, QML, etc). This not unlike what Android was/is doing - a forced growth where the race is on to pump R&D *before* the large footprint of deployed tech becomes a maintenance nightmare. On the flip side, this makes developers reluctant to write for *current* stable releases as stable is a mostly-working-kind-of-stable and they know not only there is something new and shiny coming up (it always is), but that it is coming *soon*.


Desktop vs Mobile

The long and successful history of Qt means there are (tens of) thousands of developers fairly familiar with Qt. However, this does not translate to mobile applications galore for several reasons. First of all, those people need to be motivated to write high quality mobile apps. They will not start to develop for mobile devices just because they are there, not any more than an enterprise Java developer would drop everything to make midlets. Sure, if someone is already familiar with a technology, that person will likely use it in it’s hobbies too - and that’s it, "desktop Qt people" are NOT the base that will spawn the bulk of serious mobile Qt developers/companies - those people will come from people with existing mobile background or interests. This seems to be slowly being realized now, as porting tutorials for Android and iPhone started appearing on Forum Nokia. This is an important shift, and while might be characterized as aggressive, it’s exactly those developers that need to be targeted to get the Qt ecosystem on the mobile industry radar.


The big GTK+ migration

Since July 2009, it has been known Qt will take the place of GTK+ in Maemo/MeeGo. To be precise, this is not as much about GTK+ itself, but about the GTK+ based Hildon application framework, initially developed by Nokia. It is understandable that such a major change touches on many existing developers and that such transitions are always difficult to manage. However, there were a lot of indecision and mixed signals from both Nokia and the community as to what exactly should be done "for now" and "for the future", what is or isn’t available in Qt and just how important it is for Qt to mimic/fit in the existing, but deprecated Hildon environment. In retrospect, once the strategic choice of going Qt was made, the push for Qt should have been much stronger, helped with migration plans/tutorials for existing developers.

 The big Symbian migration

Almost literally the same applies to Symbian people. While nowadays it will be hard to find large gangs of fierce AVKON supporters and the public/private API approach of Symbian, there is still a significant "why do we need Qt" notion. It has to be made clear AVKON is dead and, again, just as with GTK, handing out Qt tutorials that start from scratch will not help as much as good, targeted migration plans/tutorials for Symbian people. Just putting Qt on a Symbian handset preinstalled will NOT be a sufficient motivator for existing developers.


New vs existing developers 

As seen from my stance in the "desktop vs mobile" section, it is clear why I think people already doing or interested in apps for mobile devices are important, and there has simply not been a widely successful effort (yet) to help ease people into Qt’s way of doing things. This is well illustrated in the experience with Maemo - most Qt apps were written by people who came to Maemo *first* and *then* started doing Qt.

You have Python - use it. 

There are two Python binding projects available for Qt, both open source but neither have the status of being an "official" Nokia binding and Ovi not supporting Python apps at all. Again, from Maemo experience we see that there is a huge interest in these because even with the limited documentation and support available the number of Python apps is comparable to the number of pure C++ Qt apps due to the low entry barrier of Python.

TIMTOWDI*

Some people will snarl at this, but.. there are simply too many ways to do things. Or, rather, there aren't (sufficiently) recommended ways of doing things. Quality training material is starting to appear, but any time somebody asks how do I do a GUI there needs to be a longish discussion as to what version is being targeted, what tools are acceptable, etc, etc. If there are 5 ways of popping up a Hello World dialog (many of them quite 'old school'), know that people WILL get lost or at least discouraged when they try do merge docs from all over the net.


Show me the money

As seen/heard from many professional (as in for-money) developers on various Maemo forums, they do not really care about Qt. Sure, it’s cool and a lot friendlier than some previous approaches, but the ultimate test for them is the market. If a super-appstore existed and it required you to code in assembler, it wouldn’t matter much, these guys would just bite the bullet and do it that way. The morale ? Technical merit seems to influence adoption rate a lot less that many believe and the primary aspect are really cost and perceived benefit. Let me emphasize - this only applies to large-scale commercial development, FOSS and hobby coders *will* be affected a lot more. And while we are talking about money...

The closed door

One of the lures of application stores is that they are simple to use, accessible to one-man-show developers, and, well, 'just work'. Unfortunately, Ovi was not really ready for the Qt apps (or the N900) in the planned 'end of 2009' timeframe - whether they had more important things to do or more important holes to fix, I wouldn’t know. In any case it took a hefty extra 6 months until you could actually submit Qt applications to Ovi, and the Ovi QA process for these is still trailing the community QA process in many ways.

Chuck Norris releases PR1.2

Well, at least for onlookers it felt like it would take Chuck Norris' superpowers to get the infamous PR1.2 firmware released for the N900. This alone was not a problem, firmware delays happen, but the bundled nature of firmwares meant that Qt4.6 that was ready at the end of March could not be distributed until the end of May, a 2 month delay for no reason at all. On a side note, due to bad communications, this issue caused an outage of several weeks for community developers unlucky enough to depend on packages that have been changed in the update. While this particular incident was Maemo-specific, the Symbian counterparts are not immune to such risks.


So, does all this mean Qt is doomed, the future is grim and is all hope lost ? Not at all, as you might have noticed, many of the issues are growing pains, have already been resolved, or are at least in the phase of being taken care of. The change that is going on is really huge, a lot bigger than a lot of people realize, however, it would be not be sincere to say all will be peachy from here on. Even though the time for reaping the benefits is finally closing in, there are a few points that need to be addressed before Qt becomes a no-brainer for both commercial and community development and all those apps start pouring in. Tune in for for the final, third part of this series to see what these are.

So, where are those mobile Qt apps ? (Part 1, History)

As part of a testing and compatibility effort, Nokia announced Qt to be officially available on Maemo 5 (i.e. the Nokia N900) on the Maemo Summit in October 2009. A lot of time has passed since then, and despite the sizeable Qt developer community and popularity of Qt on desktops, the number of Qt applications remained fairly low. This is true for both among the (admittedly few) commercial apps and in the (thousands strong) Extras community repository. In this three part blog series I’ll try to analyze what are the causes for this shortage and what needs to be done to remedy this situation lest it continue onto MeeGo and future Symbian versions.

This series consists of three parts (yes, I finally realized my posts are too long) :

1. History - the timeline of Qt with regard to Symbian and Maemo/MeeGo
2. Adoption - describing what problems have hindered a "more than words" Qt adoption so far
3. Resolution - what are the remaining logjams and how to break them

As described above, in this part, I’ll write about the history of the Qt timeline in Maemo/MeeGo in order to gain some perspective:

• 2008 Jan - Nokia buys Trolltech (makers of Qt) 
• 2008 Apr - Qt support for Maemo is announced
• 2008 Oct - First Android handset released
• 2008 Dec - Qt4.5 becomes available as a community edition for Maemo 4.1
• 2009 May - Symbian^4 deprecates AVKON and carbide C++ in favor of Qt4.6 and the Nokia Qt SDK
• 2009 Jul - Qt4.6 is announced as the base application framework of Maemo 6 (Harmattan)
• 2009 Oct - Official Qt support (4.6 for 2010Q1) announced for Maemo 5 on the Maemo Summit, and beta made available
• 2009 Nov - The N900 ships with the not-overly advertised community Qt4.5 version, first post-ARM11 Android 1.6 is released
• 2010 Jan - Stable Python Qt bindings are released
• 2010 Feb - Nokia and Intel announce MeeGo, Qt4.6.2 released with Smart Installer beta allowing install of Qt apps to existing S60 devices 
• 2010 Apr - The Nokia N8 is announced, the first Symbian^3 handset that will ship with Qt4.6 preloaded, bridging old AVKON based S60 and the future Qt based Symbian^4
• 2010 May - After much delay, the PR1.2 firmware for the Nokia N900 is released with Qt4.6.2
• 2010 Jun - The Nokia Qt SDK is released and Ovi store starts accepting Qt apps 

The Qt toolkit is one of the pivotal points of Nokia’s future strategy as it will be the base of it’s MeeGo handheld user experience and also the umbrella that will unite Symbian and MeeGo from an application developer perspective in the future. We can see that this is no short term plan - it took quite some time to arrive here. Just to put things into perspective I included a few Android events. This should also make it clear how "new" the Android arrival is and how it hardly fits the Qt strategy on the platform level - though I would still like to see Qt apps on Android.

In any case, seeing the timeline it is obvious that the Qt strategy was not a whim, it was a broad, consistent strategy. Qt has come a long way, it has been available to developers living on the mobile edge for well over a years (and two decades for those that are familiar with Qt from the desktop). It fought it’s way to actual devices and stable repositories (an install base of several million handsets via the Smart Installer and the N900 since PR1.2). Ovi now accepts Qt apps. The Nokia Qt SDK is released with the nifty QtCreator IDE largely reducing the pains of the powerful-but-linux-guru-oriented scratchbox environment of the Maemo SDK. The Qt API is a lot friendlier than the AVKON APIs or the generic rag-tag Linux APIs ever were. There are already thousands of developers (both FOSS and commercial) with a lot of previous Qt experience. Qt is touted as the future of all Nokia smartphones. We should be swimming in cool Qt apps, right ? Well, sadly, as many N900 owners are painfully aware, that is still not quite the case, and while there are a few community efforts and the telltale commercial app, it’s far from a landrush. In this blog post I have outlined the Qt’s history, it’s promise on mobile platforms and all the good stuff. If you want to know where the sand is slowing the gears down and what both Nokia/Intel and the community can do to unblock the cogs, check back in a couple of days for parts two and three !

The Ultimate MeeGo Dictionary

There is quite a blizzard of very similar terms when it comes to discussing MeeGo and Qt matters, so I decided to put together a small dictionary which will hopefully clear up some terms and help follow up info on them. Don't worry if it's slightly confusing or contradictory at a first read, that's normal. Here we go, in alphabetical order:


DirectUI - see MeeGo Touch Framework

DUI - see MeeGo Touch Framework

Fremantle - see Maemo 5

Harmattan - see MeeGo-Harmattan

Harmattan UI framework - see MeeGo Touch framework

Harmattan UX - the user interface and applications of MeeGo-Harmattan. 

MADDE - Maemo(/MeeGo) Application Development and Debugging Environment, offers the following features:

• Command-line cross-compiling
• Multi-platform support (Linux (32-bit/64-bit), Windows, Mac OS X)
• Configurable for different targets & toolchains
• Client for the device to simplify the development process
• Will be used as part of future releases of the MeeGo SDK, along with QEMU, to enable cross-OS development.

Maemo - a software platform developed by Nokia for smartphones and Internet Tablets. It was initially based on the Debian Linux distribution. One of the predecessors of MeeGo, along with Moblin.

Maemo 5 - the default operating system on the Nokia N900, and current latest stable and independent version of Maemo. Based on the GTK toolkit. Aliases: Fremantle

Maemo 6 - see MeeGo-Harmattan

Maemo 6 UI framework - see MeeGo Touch framework

MeeGo - an open source, Linux project which brings together the Moblin project, headed up by Intel, and Maemo, by Nokia, into a single open source activity. Managed by the Linux Foundation. The important thing to note that you end users will mostly be using an edition of MeeGo, MeeGo itself is not a single product (that’s why "will X run/get MeeGo" is a bad question), just like people are using a Linux distributions, not Linux (as in kernel) alone. 

MeeGo Compatible - something that implements the MeeGo APIs, but is not necessarily based on MeeGo Core (for example Meego-Harmattan).

MeeGo Core 1.0 - the base of every MeeGo system (diagram), contains

• Kernel based on Linux 2.6.33
• DeviceKit and udev for interacting with hardware devices
• Modern 2D / 3D graphics stack including Kernel Mode Setting, non-root X
• Voice and data connectivity with Connman connection manager, Ofono telephony stack and BlueZ Bluetooth
• Qt 4.6
• Universal Plug and Play (gUPnP)
• Media frameworks
• Next generation file system BTRFS, as the default file system
• Does NOT contain a user interface or end-user applications !

MeeGo Garage - A client app installer in the MeeGo 1.0 Netbook release containing miscellaneous applications not part of the official MeeGo release and open for contributions from community. The name "Garage" may be changed in future releases. Ongoing community work is happening to create the official community repositories.

MeegGo Handheld - MeeGo Core + MeeGo Touch Framework + Reference Handheld UX (not yet released).

MeeGo Hardware adaptation project for the N900 - Nokia as founding member of MeeGo project is using N900 as the ARM reference platform of MeeGo at the moment. This means that we have an active project that focuses to make a MeeGo hardware adaptation for the N900. The goal of the project is thus to open as much N900 specific drivers as possible in MeeGo scope.

MeeGo Hardware adaptation project for the N8x0 - a 'skunkworks' project by the maemo.org community and others to bring MeeGo to Nokia N8x0, hence not a vendor-pushed hardware adaptation. Initially focus will be on Nokia N810. Some additional work to add support for ARMv6+VFP is also included in this.

MeeGo-Harmattan - the default operating system of the Nokia N9. Successor of Maemo 5, but based of the Qt toolkit. Originally named Maemo 6, but later rebranded as MeeGo-Harmattan (provisional name). It is MeeGo compatible (that is, has a MeeGo API) but is not to be confused with MeeGo 1.0 Handheld (as it is NOT based on MeeGo Core). MeeGo-Harmattan will not be released as a Nokia product for the N900. Aliases: Harmattan, Maemo 6.

MeeGo Netbook - MeeGo Core + Reference Netbook UX

MeeGo SDK - A software development kit for MeeGo

MeeGo Touch Framework (MTF) - provides the features needed for developers creating applications for touch-enabled devices. Features include standardized window navigation, list and other widget behavior, and common theming for components.

MeeGo Web RunTime - Web Runtime (WRT) allows web developers to use standard web languages — HTML, CSS, and JavaScript — to create applications for mobile devices. WRT exposes the features of the underlying platform so that applications can interact with device data and combine location-based context with web information.

Moblin - short for 'mobile Linux', is an open source operating system and application stack for Mobile Internet Devices (MIDs), netbooks, nettops and embedded devices. One of the predecessors of MeeGo, along with Maemo. 

Moblin 2.1 - last stable independent release of Moblin 

Moblin 2.2 - see Meego 1.0 Netbook 

Nokia Qt SDK - A custom version of the Qt SDK, which includes additional functionality for developing for Symbian/Maemo devices (with announced MeeGo support later on). These include tools for cross compiling (see MADDE) and simulation. Not to be confused with the Qt SDK as the two are not interchangeable due to a custom mix of features (neither is a a superset of the other)

Orbit - see UI Extensions for Mobile

QML - a Declarative UI tool, in effect a markup language that defines UI elements and their behavior in a declarative manner, allowing, snappy, whizzy UIs. Present in Qt4.7+

Qt - a cross-platform application and UI framework. Using Qt, you can write web-enabled applications once and deploy them across desktop, mobile and embedded operating systems without rewriting the source code.

Qt Quick - the Qt User Interface Creation Kit, which consists of QML, a specialized editor in QtCreator and all-around support for the declarative approach. Present in Qt4.7+. Aliases: Qt Declarative, Declarative UI, Bauhaus.

Qt SDK - The software development kit for the Qt framework

QtMobility - extends Qt with libraries providing additional features for applications targeting mobile platforms. These include the Service Framework and Contact and Bearer Management APIs, Messaging, Sensors, Camera, etc.


Reference Netbook UX - a reference (example) implementation of a user interface for netbooks, utilizing Moblin’s Clutter-based MX toolkit. It is expected to be replaced or augmented with manufacturer provided user interfaces/system applications on actual devices.

Reference Handheld UX - a reference (example) implementation of a user interface for handheld devices, based on the MeeGo Touch framework. It is expected to be replaced or augmented with manufacturer provided user interfaces/system applications on actual devices.

Uiemo - see UI Extensions for Mobile

UI Extensions for Mobile - an extension library for  Qt, which contains more than 50 UI elements tailored for mobile user experience. There is a proposal to use Orbit and Qt together with Direct UI as a replacement for the existing S60 'Avkon' set of UI elements in Symbian^4, but has been demonstrated to work on Maemo, too. It was previous known as Orbit before getting renamed to UI Extensions for Mobile (uiemo) and open sourced. Aliases: Uiemo, Orbit


That’s it, if you feel there is a Maemo/MeeGo/Qt term that needs clarification and is missing from the list, or that I’m wrong on a term, please leave a comment, thank you.


EDIT: This page is also present on  http://wiki.meego.com/Meegodict and will be merged into http://wiki.meego.com/Glossary (pending review and corrections).

Much Ado(be) over noth(tml5)ing ?

By now the Apple - Adobe war is in full swing and the the sides in this conflict are stating that they hold the key to the technologies for the ultimate user experience. But let us just take a peek behind the big words and statements and see what exactly is on offer here.

First, let's set up the initial positions - with the processor power and resolution of mobile devices increasing at a breakneck pace, a rich web experience has become very important to companies wanting to sell the latest & greatest gadgets. Apple has clearly pledged itself to supporting HTML5 for the rich user experience on it's platform, while Adobe (obviously) claims that 'full Flash', on mobile devices is the answer to that problem. The important thing to notice here is that both technologies are in essence desktop technologies that are expended to fit the use-case of mobile devices.

So far, most of the Apple vs Adobe dispute has been on the level of announcements, open letters, endless speculation on gadget forums, but now, the first tangibles are showing up. For a long time, full Flash (at least for 9.x) was an exclusive for Maemo devices, but with the Open Screen Project Adobe promised to bring Flash to the masses, primarily to Android, whom Adobe sees as the prime opponent to the iPhone platform. It sounds a bit like a rebound affair, as Adobe tried really hard staying within Apple's walled garden, but in the end, it became clear that it was not welcome (whether the end of the affair was more to technical or business reasons, I leave up to you to decide on).

What happened happened, Android is the newfound love for Flash, even overtaking the ultimate-flash-experience incumbent, Maemo, and promised to be included with FroYo, aka Android 2.2, with some people already testing the beta on the Nexus One. So Android gets Flash 10.1, everything gets peachy and super-hardware-accelerated, right ? Well, as usual with major shifts in technology, it's not that simple. Let's see what EXACTLY is the Flash 10.1 promise on mobile devices and if actually is what you expect from it (don't worry, I'll talk a bit about HTML5 later, too).

First of all, it's important to understand how Flash works. Just having a 10.1 in your version string will not make everything super fast and instant. Yes, Flash 10(.1) brings a plethora of generic improvements, but 'AS engine improvements' and similar just don't sound as good as 'hardware accelerated'. Does it matter, if we're getting both anyway, you ask ? Well it does, as there might be a whole lot less hardware acceleration than you think. Mobile devices are far more diverse, and peope take a lot for granted when coming from desktop environments, especially when it comes to drivers.

Phones and drivers ? What is this guy talking about ? Well, if you take a look at what the Adobe beta test page, you'll notice that there are minimum hardware requirements, software requirements, etc. I can already hear - but my device is getting FroYo, so why should I care ? Think about it this way - does the fact that your computer is getting a new OS automatically mean all the new cool games will run on it, too (and well, while we are at it) ? To take things into further perspective, notice that even the FroYo beta does not have all that hardware accel snazz - a very notable point is for example is that it does not yet have hardware enabled h264. Sure, you say, but it will come with the stable release, right ? Certainly, but are you sure that your hardware actually supports hardware functionality required for it ? Flash will fall back to the trusty software decoder (just as it does now), but the important lesson here is that Flash (like HTML5 for that matter) can only leverage hardware functionality already present. Even having h264 support on the chip or chipset manufacturer does not guarantee hardware acceleration as such hardware requires the proper drivers and middleware, and, more importantly, that the content is encoded in a profile and resolution that is supported. Before you rush off to dig in some hardware spec chart, let me say that 'most' chips support 'most' popular codecs, but that the landscape is nowhere as nearly uniform as in the X86 world - ARM chips get customized quite a bit by the actual manufacturer, so saying 'Cortex A8' does not give you anything, you have to be more specific than that. This is especially true with HD content, which is practically unmanageable without dedicated hardware support (the real question as to why you would want to play back high-end HD apart from maybe as a video out to a TV or projector is a different matter altogether).

Let us return to the story about Flash though. The already mentioned requirements page tells us about interesting things - like minimum processor speed for a given screen resolution, or operating system. For example, it says that a minimum for VGA (640x480) displays is a 550 MHz Cortex A8 (up from last year’s ARM11 requirement), and for a 800x480 resolution, an 800MHz variant is required. Surprise, surprise ! The first resolution/processor combination covers very few devices (sounds very much like the Palm Pre, but PalmOS is not on the supported list, so who knows) ? The second group is, however, more interesting. WVGA (800x480) Cortex A8 based devices ? Well, we have plenty of those by now, but curiously quite a lot of them fall just a little bit short of the requirements. For example, the Motorola Droid/Milestone only clocks it's OMAP3 to 600MHz, and the Nokia N900, another OMAP3 600MHz device misses out on the supported OS list altogether even in it’s MeeGo incarnation (even though Maemo, MeeGo’s predecessor was THE platform to go to if you needed full flash in your pocket). At this point, the notion is that all devices that Flash 10 has been demonstrated on last year are rumoured NOT get it (HTC Hero, the Nokia N900, etc). The real question thus becomes, how rigid and/or selective these requirements will be. The Droid has been promised FroYo but it's unclear whether it will NOT include Flash 10.1. What ?

This brings us to the next point - why said Flash HAS to be part of any Android build starting with 2.2 ? Supports and contains are neighbouring but vastly different terms. Will the official 2.2 Droid build it perhaps include a custom build or good ole Flash Lite instead ? Or will there a special exception be made ? Will it be available only on a hacked ROM (Milestone needs not apply) ? As you can see, Flash and it's performance is not exactly a given on any platform. Another example for this from the requirements table is the mention of Symbian S60. If you think this means your good ole S60 Nokia will suddenly get a new life, you might be expecting too much. How many Cortex A8 VGA (or, rather nHD) touting S60 phones do you know about ? Nokia doesn't make any and even with Samsung and other manufacturers included, the list of devices is real short and mostly obscure. Which brings us to the - yes, you guessed it - next point.

One of the key difference the Open Screen Project, and the latest Flash releases within it tried to address is the problem of fragmentation. A million versions of flash were a pain to upgrade, especially with the diverse hardware base mobile devices give. So one of the ideas was to be able to make Flash updatable so the content and support would not get bogged down by supporting everything they have release in the past 5 years. Cool, but there is a catch - first, who will provide the initial update to the new flash platform which will then be able to update itself ? Correct, you will have to receive it via a firmware upgrade, and considering Flash 10.1 is for most platforms still months away, until it gets released, then productized and finally pushed to end users, it will be a huge commitment for manufacturers of then-legacy devices, and I not at all sure how many of them will actually commit to it. Second - the story does not end with your device and Adobe. How will your manufacturer deal with out-of-order updates to core software ? The provider you are using can also say a word or two and/or prevent the upgrade (will the upgrade checks be filtered ? Will they cost money ? Will they ultimately require a 'go ahead' ?). A lot of uncertainty there, too.

You might be thinking I'm writing all this for pitching HTML5 and saying how it will solve all these problems - well, it won't. In fact, it will have to face exactly the same problems (just having a video tag and a HTML5 compliant browser alone sure won't make your video accelerated, ditto for fancy canvas operations). Another issue is the famous codec question (whether h264 is really free and set to be a real standard). In many ways, that reminds me of the GIF/PNG feud (for those not familiar with the matter, GIF was the widespread, but patent encumbered format, while PNG was the Free, but with limited support from major players of the time - namely Internet Explorer). Having a standard is one thing, having a standard that everybody supports and does that in a reasonable way is entirely different. On top of this, those who dissmiss Adobe often neglect that the time until HTML5 matures (which will certainly take a a year-or-two-or-three) will not be met idly - Adobe will be wanting to provide added value to the web more than ever and they will certainly be looking to find things not covered by or inherently problematic under HTML5 - we are now just at a point where the small hops of Flash and the giant jump of HTML5 happen to be in a fairly similar area.

All in all - don't worry about what device you choose, as there are no guarantees about anything at this point it's almost impossible to tell what exactly will you get with *proper* Flash 10.1 or HTML5, and whether either will be included in the ever-awaited next firmware update, or how the web itself will use and embrace these technologies - both will be staying with us for a long time, and actual ’unavailability’ will be determined by the technologies and version requirements of specific sites, not the devices themselves.

Fighting The Curse Of Plenty: Nokia's Qt SDK

One of the key differences between mobile and desktop development (apart from the obvious GUI stuff) is that applications cover different use cases from their desktop counterparts. How does this difference in application focus and required tool complexity reflect on open, modern, Linux based mobile platforms, and how does Nokia's newly announced Qt SDK address this ?

Android and WebOS took the top-down approach, and made a streamlined development process heavily based on existing technologies (the Java language in the case of Android and web related tech in WebOS). This allowed for fast application development, leveraging existing developer resources and knowledge for the particular platforms, at the expense of making the jump to native code a bit more difficult or the realm of hackers. The very important lesson here was also that they very successfully hid their Linux roots, not making the Linux heritage a drawback (to the point that very few people will actually regard Android as a Linux mobile platform).

However, there was another camp, the bottom-up one, with Maemo/MeeGo and LiMo as the more prominent representatives, which promised most of the desktop technologies in a mobile environment. The advantage should have been the obvious 'just apply whatever technology you know', but in reality, this has slightly backfired up until now. While they proved to be a great basis to hack on and immediately took the hearts of many Linux diehards, there was a steep learning curve that was unappealing to many developers with little Linux background. For example, Maemo's Scratchbox environment and lack of a traditional IDE/SDK are cited being the points where many hobbyist devs gave up on these platforms. In retrospect, these factors sentenced this group of platforms to be seen in the eyes of mainstream end-users as a land of ports and emulators, with the occasional community gem application in the sea of working-but-not-quite-there-yet apps.

Returning to the title - how does this Nokia Qt SDK change any of this, especially with regard to the latter group ? The key is to understand that this is not a classic platform SDK. Let's see what exactly is happening here:

• While the technologies present in the package (Qt, Qt Creator and the cross-compiling tools) are not new by a long shot, this is the first time they start to appear as a cohesive, focused way of creating applications A-Z style.
• A classic IDE-style approach is employed that will appeal to many devs used to such tools, while keeping the power of console and functionality of other existing custom tools.
• It's a toolkit SDK, not a platform SDK. This in turn allows access to the vast array of various platforms and devices. Currently the focus is obviously on Nokia's Symbian and Maemo platforms, but here's where Qt really shines - you're not learning to code Symbian or code Android stuff. The Qt skills you learn are actually just as applicable to the desktop, whether that be Windows, Linux or Mac.
• Multiplatform authoring tools. Currently Windows and Linux, but my guess is that a Mac version could be produced fairly quickly if serious interest appears.
• While Qt provides a level of abstraction, the underpinning platform is not being crippled, and thus applications are being able to take full advantage of it.

As you can see, the goal seems to be to provide a streamlined way of producing modern applications for a range of platforms, while avoiding the dumbing down of platforms to make them fit into a particular mold. I hear you say, okay, so you think this Qt SDK thing will take over the world, right ? Well, while not excluding the possibility, there are a few obstacles that the Qt SDK needs to address before going for world domination in the mobile app development arena:

• Unified (declarative) UI. Cool compilers and cool IDEs do not necessarily mean cool apps. It is paramount that a unified API (based in some form on the Declarative UI of Qt4.7) exists for widgets and app UIs. If each app will have to have it's UI rewritten due do Orbit/DUI/vendor specific/desktop widget issues, that will significantly reduce the appeal of Qt and proliferate curse-of-plenty problems.
• Do a final release in a reasonable time-frame. Today we have seen a beta to whet our appetite, but the other tools and platforms have a serious headstart. Winning Symbian folks over is a good start (the inclusion of Qt libs on the new Nokia N8 will kickstart this process nicely), but the real race is to get on the radar of developers currently under heavy influence by Android and the iPhone.
• Go for Android. This topic alone is grounds for another blog post. Technically, it's known to be possible, there is even is a community level Qt for Android port floating around. I will not go in the business/technical reasoning of the dangers/wins of such a move (maybe in another post), but I feel that it needs to be kept at least as an option, an ace up the Qt sleeve if you wish.
• Add python support. The use of Python Qt bindings has a long and successful history. Python is easy, and on modern hardware, a Python and Qt combination is much less a drag than it ever was on embedded platforms, as proven by PyQt and PySide on Maemo. C++ is not everyone's cup of tea, and Python is an excellent complementary language for it, while maintaining a solid Qt based 'upgrade' path should developers need it. Doing this without switching SDKs or IDEs would go a long way of making Qt even more appealing to new developers.

If you want to take this new SDK for a spin, you can do it here.

Operation Qt Shuffle

I know you all like (cough) my long winded and analytical articles, but we'll take a short break from that to allow for a service announcement concerning our busy Qt developers, Maemo 5 and your evergreen favourite update, PR1.2. 

If you're an end user, the short version is - the doors are open for more (and prettier) apps, plus we have a bridge that will make it easy to backport MeeGo apps to Maemo 5. If you're a developer and/or are interested in the gritty details, read on:

[Maemo community council hat]

One of the big changes PR1.2 brought us is official Qt support in the form of Q4.6 in the Nokia SDK and repositories. This change affects all applications depending on Qt currently in extras-devel. We had some talks with Qt/Nokia folks about Qt-related repository changes in Maemo 5 (triggered by aforementioned PR1.2 and potentially again later on by updates to Qt or related components). Here is the short summary:

1. remove qt4-maemo5 (4.6) after PR1.2
2. upload Qt 4.7 snapshots as qt4-experimental to extras-devel afterwards
3. as soon as 4.6 QtMobility is released, get those packages to the nokia-apps repository
4. remove 4.6 QtMobility from extras-devel
5. maybe upload new QtMobility packages to extras-devel, but only for qt4-experimental (4.7) and with 'experimental' in the package name
6. maintainers of bindings and extensions to Qt are encouraged to follow the same nomenclature in their package names (i.e. using experimental in the name if depending on qt4-experimental)
7. use a Provides/Replaces/etc libqt4-maemo5 clause in the qt4-experimental packages (Qt4.7 packages should be binary compatible with the current 4.6 ones) so the packages can be deprecated peacefully
8. QML/declarative will be released as part of Qt4.7 (so qt4-experimental only, no 4.6.2/PR1.2 support)

[/Maemo community council hat]

What does this mean in plain English ? The libqt4-maemo5-* package names are deprecated in extras-devel. Use libqt4-experimental-* if you need Qt4.7 features, or libqt4-* if you want Qt4.6. Qt4.5 will no longer be supported after the release of PR1.2

Have a nice day !