TANSTAAFL

Some people say, there are no stupid questions, just stupid answers. I disagree. Some questions are stupid. Repetitive questions, questions with obvious answers, questions the questioned could not possibly know the answer to. When a person asks a stupid question, maybe they just want to interact and that’s OK. But what if a computer software asks a stupid question?

How to create stupid software?

It is really quite easy. Here are some pointers:

1. Assume that every user knows what you know. Ask them questions only a geek can answer.
2. Assume that users are idiots. Keep telling them the same things again and again.
3. Do you have an algorithm that not solve the problem? Add another one or two that do not quite work either, and let the user choose which of the non-working algorithm they use.
4. Let users jump through burning hoops - everyone needs exercise. If they fail near the end, let them repeat the whole course.
5. If you have a dialog box with settings, do not bother remembering what has the user chosen last time. Doing the same thing again and again calms the spirit.

Difference between smart and stupid software

In short: stupid software creates problems while smart software solves problems.

Granted, every software solves a problem, but it can also create them. If a user must go out there and study information unrelated to their problem, before they can use an application, that is a problem. If the software irritates the users and makes them feel stupid, it is a problem.

Smart software has reasonable defaults, with optional geek settings hidden behind small buttons. Smart application provides visual feedback and lets the user see the results of an operation and does not rely on users’ imagination. Smart software respects the user.

All developers are guilty

Including myself, many of my decisions have made my software more stupid. It is usually a symptom of not being balanced and overreacting to something. And it is so damn easy to slip.

A perfectionist would implement a feature with all the bells and whistles and ignoring the users, who just could not understand them.

A fearful person would warn the user via a message box just too often. “Look, you have chosen to load a saved game, but wouldn’t it be better to save your current game before (even if all your characters are unconscious and dying)?” (NWN2)

A lazy person does not have the will to implement a feature properly and instead copies a similar code from somewhere.

May the balance be with us…

It is almost 4 years since my first application was released and there is a threat on the horizon. The threat of feature bloat. Becoming the dreaded bloatware. Each new version added something to be more (or less?) powerful. When I watch people working with the application, I can see they are only using a tiny portion of the features. Adding a new feature may actually make the experience worse for them.

If you are wondering how I am able to watch people working with an application, it is through youtube. Granted, videos recorded by users just for fun and posted on youtube are not a representative sample. There may be people, who dig a bit deeper and find some of those useful features I worked so hard to implement. On the other hand, maybe things are really that grim. In that case, feature bloat is a very real problem for me.

Ways to deal with the bloat

What one user considers bloated software application with lots of unnecessary functions can be exactly the right thing for another user. Newbie users would like to have the simplest possible application that accomplishes their task. Experienced users would expect each new version to deliver more advanced features.

While it is sometimes possible to simplify a function yet make it more powerful, it is not always the case. What to do in cases, when extending the functionality makes an application more complicated? There are multiple ways:

1. Once all the crucial needs are covered, stop adding any significant new functions. Good for newbies, but experienced users may complain that the software is not evolving and look elsewhere.
2. Keep adding features and embrace the bloat. Experts will be happy, but the learning curve may become very steep making new users very unhappy.
3. Re-invent yourself in each new version. For each added feature, remove another one. This way, the bloat is reduced, the application is evolving, but expert users can be a bit irritated by the fact that their favorite features are being removed and they must partially re-learn the application with each new version.
4. Branch the application. Make a Lite and a Pro version, targeted at different users. There is of course the risk that even newbie users choose the Pro version, because people want “the best” for themselves. Also, two applications instead of one must be maintained.
5. Make an adaptable user interface. This is a variation of number 4, but distinct enough. The adaptability may manifest itself as the personalized menus in Microsoft Office XP or as the plug-ins in the Firefox browser. Effectively, there are multiple interfaces and the maintenance and support costs are rising. The personalized menus were considered a nuisance by some users. Firefox’s plug-ins make upgrades difficult as plug-in authors must check/update their plug-in for each new version. This is not an easy path to walk.
6. Focus on educating users. Each added feature must be placed properly in the application and introduced to the user in the right moment. This is very hard. People usually do not read documentation. They just look for familiar things and explore the application as long as it amuses them. If they run into a complex feature before they understood its prerequisites, or if it is not introduced to them when they are able to comprehend it, their attention is wasted. In short, distance education is hard.

Which path to choose?

The mentioned approaches cannot be easily combined (with the exception of the last one). While you can try to combine more than one approach, I would advise against it. Each approach has its costs, its weak and strong points. Combining them may cancel out the advantages and you still would need to pay both costs.

I cannot recommend you the best approach. The best depends on your application and your long-term plans. What I can do, is give you a couple of examples (my field is computer graphics, so do not wonder that I am using graphic tools as examples):

#1 - freeze

Few years ago I did a very simple application for photo resizing. I took path #1 and refused to add any new significant features. While the change log is pretty long, do not be fooled with it, all those are mostly trivial 30-minutes changes. I chose not to add support for non-.jpg pictures, refused to give it proper user interface or features for rotation, cropping or canvas extension. Approach #1 is suitable for very focused products for non-expert computer users. There is a lot of them.

#2 - bloat

Adobe Photoshop is is typical example of the second approach. They keep adding features to their already overloaded solution. They can afford it, because they are considered the best. Their application is hard to use for newbies (the existence of hundreds of sites with Photoshop tutorials is a proof of this fact). Newbies still invest their time to learn to use Photoshop, because it is considered best. It is a closed circle. Because you are best, you do not need to focus on newbies. Newbies invest their time to learning to use what they consider the best. Hence, if your product is considered the best, you can adopt approach #2. Just do not overdo it or you’ll lose too many newbies. This does not work for the second best though ;-).

#3 - reinvent

I am actually having a hard time finding an example application for approach number #3. I might be walking on a thin ice, but I believe Office 2007 or Windows Vista could be considered a fairly good examples. There was a significant overhaul of the user interface in both cases. Experts were irritated, but Microsoft had no other options. If you are unwilling to focus just on experts or just on newbies, and cannot persuade the newbies to learn the advanced features, approach #3 might be the right way. Making product for everyone is like politics (eeek).

#4 - split

Approach number #4 is quite common. There is a lot of Lite and Pro versions. Often, there are also different licensing terms, Lite being free and Pro being paid. It makes sense, those who invest their time to learn the application usually use it in business scenario and do not mind paying for it. But there are people, who do not like using Lite versions, they have the feeling that the Lite version is just a demo and developers do not pay attention to it. I have never seen a Lite version become popular, it does not get the attention of media, because there is something better: the Pro version. But that does not get the attention either, because it is paid and has to stand against other commercial products. In general, avoid approach #4. If necessary, split product by use cases into non-overlapping applications.

#5 - adapt

Firefox and its plug-ins. It is very customizable, experts can find the right plug-in just for their unusual needs and newbies get an easy-to-use application. This is very nice, use approach #5 if you can afford it. Developing an application with a solid open interface is more difficult than a monolithic one. Then there is a trust and stability issue. Are the plug-in authors trustworthy enough? What if I install plug-ins from 2 different authors? Would there be a conflict? It is impossible to test every combination of plug-ins. Designing and maintaining a flexible system has its costs.

#6 - teach

Do it. As much as your resources allow you to. You cannot go wrong by explaining users how to work with your application.

Summary

None of the solution is perfect, some may only work for a limited time. Depending on your situation, you may need to switch from one approach to another one. The important thing is knowing, where you are now and where you want to be in a couple of years. Then the right choice may just seem obvious.

How to define “the power” of a software application? From time to time, people on discussion boards use the adjective powerful (or best) in conjunction with software. What does it actually mean? It may seem obvious. But as many obvious things, it is actually quite foggy.

What is powerful software?

Since I develop software related to images, let’s limit the scope of this paragraph to “what is a powerful image editor”.

Definition v. 1: The most powerful image editor is the one that allows users to modify images in just about any format in just about any way.

By this primitive definition, a simple hexadecimal binary editor would be considered the ultimate, most powerful image editor on Earth. This is a clear nonsense. User must be part of the definition.

Definition v. 2: The most powerful image editor is the one that allows user to perform as many tasks as possible. Task must relate to image editing, but they are defined by the user.

This is better. If we are given a single user, we can measure how successful the software was. If a software has features needed to perform task X, but the users is unable to find/use them, it does not contribute to total power.

There are still problems with the current definition: Each user is different, they have different skill sets, knowledge, and the tasks they want to perform. It is clear that we must work with a representation of all the users instead of with just one. It would be reasonable to represent all users with a couple of typical ones. Each one should have a importance factor associated with him/her (bigger group = bigger importance).

Definition v. 3: The most powerful image editor is the one that has the greatest sum of successfully completed tasks for all relevant users.

If there is only one user (the author :-)) able to fulfill 100% of tasks and all others are only able to perform 10% of them, the total power of the software would be near the 10% mark. On the other hand, consider another software allowing all of its users to perform 20% of their tasks. Which one would you rather create and sell?

How to increase power of your software?

If we agree on the last definition, it gives us hints how to increase power or at least avoid decreasing it:

Add feature

This is the common strategy. All software developers love adding features and making check lists. Adding features allows users to perform another task, previously impossible. But it also makes the software more complex and thus decreases the users’ ability to use the application. In short: it significantly improves one task, but slightly worses all others.

Remove feature

Yes, removing certain features from a software can increase its power. Many software developers (including me) have instinctive aversion to removing features, but we should know better. Removing a feature may worsen task X, but other tasks should improve, because the application is easier to use with less features. Sometimes even task X may not worsen, because it can be accomplished using other features.

Add tutorials/context help

Teaching the users how to perform a task in your application can drastically improve its power. While it is imaginable that too much dumb help may actually worsen the application, it is usually not the case. Personally, I’m switching to web-based (mediawiki actually) help, it gives me the maneuvering space to quickly react to users’ needs in this area and to use modern technologies (like tutorial videos).

Simplify user interface

This is actually a variant of the “Remove feature” hint. 10 years ago, only people with affection for technology used computers and Internet on daily basis. Today, as the number of people using computers increases, the technical knowledge and skills decrease on average. Making the user interface simpler can open new market segments and hence make your software more powerful in the end.

Summary

Removing a feature that took a lot of time to implement is hard for each software developer. Nevertheless, in today’s world it is often the right strategy. If you believe that your software has the best features and people still like using competition, which evidently does not have as much functions as you, consider removing or simplifying it.

The situation might be even harder in an open source project without a central authority. The GIMP is obviously overloaded with features and the sheer amount of them prevents most users from working effectively.

I have and will continue following my own advice and keep this blog updated.

- It won’t hurt, I promise.
- But you are invading my privacy!
- Not at all, it is just a probe, it is not like if I used my bare hand or such. This red light will tell me if there is something shitty inside your computer. That’s all.
- Should I take your word for it? What about source code to backup your claims? Your probe runs with administrator rights and it can do anything.
- I don’t think so.
- I do not want it!
- Well, then we’ll wait till you change your mind. Isn’t waiting fine when we already have your money?

The facts

Few days ago, the automatic updater in Vista notified me about new update being available. Because I know that keeping the system up-to-date is crucial when fighting viruses (this is especially true if you do not have a firewall in your modem), I have checked the update immediately. To my astonishment, all the other updates that were previously available for installation, were gone.

The only thing left was KB940510. I usually don’t do that, but this time I have checked its description: “…enable Vista to detect software that bypasses activation…”. So, nothing useful, just 3MB of junk that is going to search through my XXX files. Why is it called an update?

I thought that maybe the disappearance of the other updates was just a glitch, but I do not think so anymore. They have appeared right after I gave up and installed this useless update. Now I am officially probed. What a shame.

The moral

Still, things could be worse, but not much worse. This probe was disguised as an update, but at least the description was telling the truth (hopefully).

It also demonstrates that Microsoft takes the fight with pirates seriously and they will use any methods in enforcing their rights. Each action like this only lowers the user experience of the paying customers, because it shows to them that they do not really own their OS, they are just allowed to use it. If they behave.

In the end, what is the point? Pirates will find a way around it anyway.

It is my belief that the problem of software piracy can not be solved by technological means. It is a social problem and must be solved as such. I am a shareware author and there are cracks and serial number generators for my applications. It does not bother me (much), the people who choose to pay did so, because they found the applications useful and the price adequate. And that is the right way.

BTW, do you know about the (under development) Windows alternative? The ReactOS.