No more empty smartphone screens

Ever since I parted ways with my trusty Nokia 3310, empty standby screens of many smartphones have felt cold, distant and useless in comparison.

Although, various Windows phones, and a handful of Android devices come equipped with features that make their standby screens appear far less dead. After all, credit must be given where credit is due.

No need for power or home key presses, display double taps or other conscious interactions. The moment they're exposed to the world outside users pocket, both the phone and its user are already one step ahead of everyone else. A digital extension of a human intention.

Sailfish OS also has a similar feature in development we call "Sneak Peek". It's not ready yet, but I've been trying it out for almost one year now. Somehow the feature always carried over software upgrades, up until last week at least. I had to re-flash my phone, turning the feature off for good.

The sudden change in device behavior has left me staring at an empty screen more times than I'd like to admit. Looking and feeling like an idiot.

One step too much

Curiously enough, I realized that all those solutions I mentioned earlier, had one important piece missing. They all focused only on what user might want to see, but ignored where that would lead: what would people do next, after already holding the device in their hand, with the display showing relevant information?

Easy. You either want to interact with it, put it back to your pocket, or set aside on a surface near you.

And the problem with everything we have out there today, is that they all just create an additional state between the display being completely off and fully on. A glance or active screen is shown first, before you can see the lock screen. If you desire to interact with device functions below, you have to first go through that extra screen. This throws away part of the potential gained through anticipating user intentions.

To allow user interaction, it would make more sense to automatically show the lock screen, without any added steps. User would see the same information, intereact with lock screen controls, or continue to unlock their device.
Yes, it would requires some adjustments to how the lock screen behaves. It might be something like these wildly conceptual images, that are created to support this post. Take them for their illustrative value.

Moreover, the appearance is secondary in the long run. How it feels in the daily use becomes much more interesting and valuable quality. At first, it might sound strange for the phone to behave like this, but let's look at what would happen if it did.

The first thing you'll notice, you can get to whatever you're doing a bit faster. People use smartphones over 100 times a day, with majority of those instances starting with manually turning on the display. As the manual part is removed, less attention and accuracy is needed.

Second, the amount of user errors would decrease, because nothing was added. Every gesture and functionality works just the same way. It's the same lock screen, nothing more, nothing less. It's just working with you, not against you.

Worried about accidentally unlocking it? Don't be. Every lock screen has a built in protection mechanism to prevent that. Made famous by that "slide to unlock" slider on the first iPhone. We flick or swipe long enough distance to get past it.

Finally, removing your device from your pocket becomes much more friendlier event.

Just pick up the phone from your pocket and place it on a surface near you. Display will light up to greet you. An accelerometer inside the phone can tell whether you're holding it in your hand, or it's resting on a table. By following that information, it's easy to turn off the display sooner to save power.

Naturally, if the phone is on a table, the same sensor can be used to detect user picking up the device. And for cases you don't want to pick it up, you're just a double tap away from whatever you need.

By now, I'm sure some of you've already wondered why not use black background with colored text and icons on top. Well, it works great if there's no display backlight. If there is, too bad. I illustrated the problem below.

Those liquid crystals that are used to affect the light passing through, cannot block all of the backlight, resulting in gray appearance instead of black. This is very visible at night, inside movie theaters, clubs and ancient dungeons.

Using a background image will simply make the issue less apparent (can be turned off for AMOLED devices to save power). Also, a user selected image is much more personal option compared to someone saying it should always be black.

Making smartphones anticipate our needs is not rocket science. Especially when it comes to the lock screens scenario that we manually go through almost 100 times a day anyway. It's much more about seeing past of our past experiences. If you see through them, and get a taste of what things could be, it's going to be difficult to go back anymore.

You'll soon realize how passive most smartphones are. As if they didn't have the information available to anticipate the most basic thing we do. Once again, you've been staring at an empty screen. Looking and feeling like an idiot.

Welcome to the club.
 

Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

 

Does the software you use have multiple personalities?

If you paid for it, or got it after signing up for a "free" service, it's a 100% yes. Some just hide it better than others.

The thing splitting a one good personality into several ones, is called business requirements. These requirements serve the existence of the company maintaining the software, and are kept hidden from the end user.

Imagine these requirements as another user next to you (the real end user). This one is just invisible. Naturally, these two users never share the same goals or values, because they're inherently different. Another one is a real person, while another just a set of objectives. This means, that the product has at least two reasons to exist; two separate masters to serve. In the light of my ponderings about good and bad software, this is how business requirements tend to change development focus.

Somehow, we all can sense this. At times, software can feel very fluid, smooth and purposeful for us. For those cases, the invisible business aspect is not interested what you or the software does. But sometimes you feel like being thrown through unnecessary hoops for no good reason. That's due to business requirements being met. Things like mandatory registration, DRM, enforced internet connection etc.

If a lot of code is needed to meet defined business requirements, it will be hard for the company to open source such a software, because it exposes all these questionable things. Not to mention making it dead obvious that a similar value is achievable with much less code elsewhere.

Therefore many companies refrain from open development; convincing themselves into believing these undocumented capabilities are for the good of everyone.

We all want better experiences, but they honestly have to deliver on that promise. There might be temptations to harness software to serve alternative masters, but it only leaves everyone wondering why it's so damn hard to openly develop software.

And why their software still has multiple personalities.

Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

 

Opinions kill open software

It's happening. Silently, slowly, without exceptions. Dead, gone, deceased. You just don't know it yet.

Some background before proceeding. My previous post, about good and bad software, underlined how important it's for everyone to know why a particular piece of software exists. Especially in FOSS development.

The problem is user expectations. Our past experiences naturally affect our preferences, and we subconciously project them to new software. This pulls developer toward how, away from what the software was created to do. And since we're all unique, it's difficult to see the real reason from our equally subjective viewpoints, steering the software into a direction illustrated below.

The reason is that FOSS users engage much more in software development, when compared to proprietary software users. Everyone knows that much about software, that anything is possible with it. It's a holy grail of every software project to be pursue sophisticated frameworks that support our highly heterogenous user preferences.

You might not realize it, but the price a proprietary software user pays in cash, a FOSS user pays in responsibility. We're all priviledged to have an alternative, and we should respect the reason it exists. Don't neglect or avoid it by suggesting yet another user setting or customization framework. That's always away from what the software can do to everyone.

If FOSS alternatives will ever reach a wider consumer adoption, they'll do so being faster to develop and maintain. By going faster to places a proprietary software is too heavy and cumbersome to go. By helping people to do more, faster, simpler and more reliably. By giving us our time back.

That's why it's imperative that the development is focused. One software can't adapt to seven billion amazing opinions, but seven billion people can adapt to one amazing software.

Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

 

Good and bad software

I'm going to start with an argument.

Software exists because people are lazy; not that it's a bad thing. Throughout the history, it's been one of the greatest sources of ingenuity. A wonderful catalyst for ridding inefficiency.

It all started with a lazy person, defining a set of instructions for a machine, for it to do something people are bad at, and machines fantastic.

Those lines of code, running on a piece of hardware, helped that person to get more work done. Ideally, the time invested in instructing a machine to work for us, is far less in a long run compared to us doing all that work ourselves, impeded by human limitations.

Software exists to use computer's potential on tasks which people struggle with. People simply need to focus on instructing it. Sadly it's the focusing part where things usually take an unexpected turn from the ideal road. Right through the safety rail of professional training. Over and off the cliff of common sense. Straight into the bottomless pit of irrational. I visualized the problem below.

Given that a same amount of people, with equal skillsets, are working on a software project with identical goals, it's more likely that they end up with what I personally think as bad software.

Such software doesn't do what software is supposed to do. If you get stuck on the user interface part, you're missing the reason why people use your product. You have just instructed the machine to play hopscotch with the user, instead solving a user problem. The balance is just way off. Bad instructions, bad software. No amount of excuses change that.

Beautiful, well performing and behaving user interfaces can be built with relatively little amount of code, if you know what you're doing. If not, you easily end up with a complex and overdone interface; a monstrosity that needs even more complex customization options to tame -- or fire to kill, as it depends.

Still, game over.

Becoming blinded and trapped by the user interface iteration loop is very easy. It's the most visible thing for everyone in the project. That's why it's so important to be aware of this danger. Adding more interface easily feels like adding more value. How wrong can people be. You only waste resources on things that:

• end up eating even more resources since you're stuck with maintaining it
• restrict your options for potential devices and businesses in the long run
• distract user from the real value your product offers = less appealing product

"But Jaakko, isn't there many other areas as well that affect software goodness / badness?"

Yes. There are. A lot in fact. However, this one is something everyone can and should understand. It doesn't take a computer science PhD to figure this stuff out. It's especially important for companies whose business depends on software quality. Even more so with startups and small companies.

I'm going to end with an argument.

Your company exists because people are lazy. Make sure your product focuses on helping them, like a good software does.

 

Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

What is keeping Sailfish OS alive

Image by Jolla

In my previous post, I used Windows phone as an example of how focusing too much on design can hurt your product. This post is a follow-up for it, focusing on the importance of design intentions and the overall reasons to do things in the first place.

Be realistically ambitiuos

For the sake of comparison, let's pretend that Jolla chose the strategy everyone expected it to choose: follow iOS and Android to join the mobile OS and smartphone business. Just close your eyes, and picture Jolla offering the same experience what Apple, Samsung and others already do.

Wonderful, here's the thing: that strategy has been perfected by Apple, Google (later Samsung et al.) since 2005. They will keep doing so in the future, without any intentions of slowing down. 7 years later Jolla was ready to compete against industry giants, with the announcement of Sailfish OS.

Enough pretending. Competing with this strategy, against these guys, is like trying to race against a bullet train, with a bicycle, without pedals. You will get nowhere; even if you pretend to. It's utterly silly to think you can beat them in their own game they've rigged beyond recovery.

You'll be spending all your time on things you can't compete with. And since everything you implement has a cost, it's more logical to find a simple solution for all those things that make your product a reality. Move through the mandatory feature list as fast as you can, so that you can save time and effort to use on what, in your vision, makes you relevant.

This is where Microsoft stumbled. WP tried to create value too close to competition, instead of building on top of and strengthening existing ones; those that made Microsoft relevant. In the end WP sabotaged Microsoft's opportunity to not limit its users to stationary computing. Their ambition to build a smartphone OS ended up instead limiting people also on the go. Looks like they're finally fixing this with Windows 10, so let's move on.

Be honest to what you exist for

Three years after the Windows phone launch, Sailfish OS rolled out as a very limited and rough experience. You were all set, if you had enough interest and patience to wade through tutorials, reviews and forum posts. It worked if you knew exactly what you were doing, but it didn't leave any room for user errors. There was hardly any guidance to help user. To be open about things, we shipped it with a beta stamp. Digital pioneers and average consumers alike received their copy, installed on the finest hardware we had access to; a mid-range phone on all accounts. A failure by industry standards.

But the thing is, we're not competing solely within industry standards; things what others already master. We have our minimal solutions for those, but our real business is where others cannot easily go. Either because they're too scared, lack the required vision, or don't really care as long as they can convince people buying their next wave of latest and greatest.

People deserve more natural and focused interfaces than current industry standards require. We need more openness, collaboration and sustainability =  a thorough value domain reset. Automation and computing in general are less about the technology, and more about finding a common direction to increase human potential; everyone deserves more time for things that are defining humanity.

What makes Jolla and Sailfish OS relevant, is our reasons to exist in the mobile space, and what our actions stand for in contrast to the competition. And that, ladies and gentlemen, is what keeps Sailfish OS alive. Not what it can directly offer, because it's not much at the moment. There's a mountain of work remaining -- actually -- make that two mountains; the operating system alone is not what you need for your computing tasks. It's merely a start.

We still need apps, more supported services and other natural functionality integration points. They are paramount in making sure Sailfish OS also stays relevant. There's a big functionality debt we owe our community. It's through their passion and trust, that we've given this chance to make a difference.

Respecting that debt would not only be human, but also an exception that this industry sorely needs to change.


Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

Too much design

www.wpsauce.com

A Windows phone design article by Paul Thurrot, summarizing a "ask-me-anything" thread in reddit, reminded me about something that easily goes wrong in design: the design itself becomes more important than the product or medium it's applied to. Meaning, that more work goes into sustaining design as an activity; instead of treating it as an integrated part of making a competitive product.

What kept popping up throughout the article, was the need to differentiate Windows phone from others, through Metro's unique visual and interaction design (mainly focusing on application side though). This resulted in design importance raising out of proportion, disturbing the actual product work (make a great product). The focus was on finding a striking and novel design (too much), instead of making a relevant alternative to iOS and Android.

Alternative can mean being different, but it doesn't have to. A product that's just different for the sake of being different, is bound to have a design overdose. The only way to deliver an industry-breaking products, is by not designing it for the industry (remember what Apple did when it entered the smartphone market). That alone requires you to focus on problems that the industry tries to hide. Too much design will just make things worse.

The mobile industry has a significant ability to resist changes. Look at any usability studies. They all basically state that Android and iOS have reached the pinnacle of touch screen interaction. To put that in some perspective: they say that majority of desktop interaction patterns (the way you use mouse and keyboard to do things) are just as usable on mobile devices, as they were 40 years ago. Nonsense.

Usability studies like that show how amazingly well people adapted to our messy past with computers. Studies can always help to spot problems in both design and implementation, but the they tell nothing about our potential, our hopes, dreams or what we'll do tomorrow.

So, at the end of the day, those studies tell that the industry doesn't want to be broken.

"To go against it (industry) you need to earn it. You need to be far, far better." Being different for the sake of difference, is not enough.

With Metro, Microsoft experienced the hard way what happens when you put in too much design, at the expense of end user value. It failed to be relevant.


Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.

The story of SailfishOS browser

Why on earth would someone start yet another browser project, when there's so many already out there? Well, because all mainstream browsers are more or less scaled down desktop browsers, than something designed with one handed mobile use in mind.

Looking at the image above, the two examples from the left are impossible to comfortably use without altering your hand grip. Also the reason for such design is obvious just by looking at desktop browser interfaces: they hardly need to be operated with one hand alone. I mean, try lifting your desktop/laptop with one hand, and enter a website address.

Even if you can somehow do it, it's not comfortable; and downscaling that interface design to 5" screens does not change that. You'll still need both hands to operate it, which is an unacceptable requirement for a simple tool that should increase your potential, not decrease it.

And that's where the third example on the right comes to play. Obviously, we're not doing everything by ourselves. We chose to build our web browsing experience on top of Mozilla's Gecko rendering engine, developed for the Firefox browser.

Then, let's look at the two major steps we took before ending up with the current SailfishOS browser design. There's some good things we learned along the way.

Version one

In addition to moving the toolbar down, the first design (click to enlarge) used separate pages for both tabs and website address. The aim was to avoid the performance hungry scenario, where some web content is rendered in the background, a virtual keyboard is open, and there's search suggestions on top of everything.

The toolbar had buttons for back, address field, tabs, reload/stop and forward. In the end, the design was discarded as too complicated to understand. The root cause was in the magnifying glass icon. People didn't associate it to searching the web.

Version two

The next image shows the design that actually shipped with the Jolla phone sales release (click to enlarge). It combined both tab and addres entry into a single page. And instead of a separate address eentering icon, it promoted easier bookmarking.

We got a lot of negative feedback for that design, as it added an extra step to searching something or entering page address, and also made tabs functionality unnecessarily complicated to understand, use and develop.

Version three

The current design brought back separated tabs and address entry points. Tabs still use a page, but the latter one behaves like a toolbar extension, so that you can still see a bit of the webpage underneath. Much more useful functionality was also added throught the expanding/collapsing toolbar.

The feedback has been really good, and although I'm not completely happy about two different gestures to get back to browsing (flick address overlay down to close it vs. flick tabs page right to close it), we're much closer to a modern mobile browser interface.

Something that supports the way your hand works, instead of how you moused around in desktop interfaces few decades ago.

Thanks for reading and see you in the next post. In the meantime, agree or disagree, debate or shout. Bring it on and spread the word.