Why Symbian failed: developers, developers, developers

Andrew's Mailbag Extra The reasons why Apple succeeded in creating a smartphone market – with OEMs rushing to follow in its slipstream with Android – have now become conventional wisdom. Firstly, the iPhone was designed to be a mobile computer first, not a phone, and was optimised around a new, radical UI. It surprised people with its capabilities and the UI was forgiving. Secondly, bundling data with the appliance reduced the risk for customers - once data was bundled, you were daft not to use it.

And there’s similar agreement on the reasons why Nokia, having planned a mass smartphone market for 15 years, missed out. Nokia’s design philosophy was that smartphones were phones first, not computers. It wasn’t in a position to dictate to its customers – the networks – how they should price their data. So because these assumptions were wrong, so were the decisions on the product and R&D. Nokia was reliant on Symbian but had neglected to develop and polish the user interface over the years. Other people point to underpowered hardware and releasing a spread of indifferent products, rather than a few good ones: these reasons are popular but not unanimous. But there’s something missing from these analyses. It’s not the full picture.

I’ve found something else. It’s developers, developers, developers.

I’ve taken soundings from a number of former people intimate with Symbian and found a strong divergence of views. What Symbian’s engineers thought of it, and what they knew it could do, differs sharply from how third-party developers perceived it. I’ve collated a few comments here. It was sparked by a throwaway remark from a Symbian veteran about strings. It inspired this rebuttal.

Symbian is addicted like crack cocaine to the word ‘ecosystem’. What you’re about to read is far removed from what that hippy, happy phrase evokes.

An engineering source who spent years in a business deeply involved in the Symbian market tells us:

Symbian went its own way with just about everything. I delivered Symbian courses all over the world. Everyone hated string handling, it provoked the biggest howls of despair: good developers, bad developers, in the UK, abroad: everyone.

Instead of threads it uses “active objects”, a single-thread co-operative multitasking mechanism with its own arcane syntax and semantics. Instead of exceptions we have “leaves and traps”. For memory management, the “cleanup stack”. And so on.

My complaint isn’t that these mechanisms were inefficient, because they weren’t. In fact they were the opposite... when used correctly. And therein lies the rub. These things were so damned hard to learn, most people just didn’t bother. The sluggish performance you see on your Nokia phone today is a direct result of developers doing things synchronously rather than asynchronously (because Active Objects were difficult to learn), and allocating massive buffers rather than doing efficient string handling (because descriptors are a pig to use). I know this because I’ve seen the code so many times: at Symbian, at Nokia, and at many other Tier-1 Symbian licensees.

Symbian boasted that back in the Psion days, EPOC was designed not by "soft" scientists like software engineers, but by "hard" scientists (their words!) with backgrounds in maths and physics who understood how to bleed every last ounce of performance out of a system. I don’t doubt for a minute that that was the case. But sadly, what those hard scientists utterly failed to grasp was the concept of usability.

That matters, because an "ecosystem" is as good as its skill set. Our anonymous source explains:

Anyone who’s spent a week or more working for a software company knows how much real production code is bashed together by short-term contractors, or by people completely new to a platform. Your platform can be as clever as you like, but until it’s so intuitive that developers take to it like a duck to water, the cleverness will all lie unused, gathering dust. "Intuitive" means having as many of the following as possible: clear, meaningful naming convention; APIs that follow existing conventions; smart, well-integrated development tools; clear and complete API documentation; good supporting reference materials; and well-commented example code. By and large, Symbian fell short on all of the above.