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.