Simplicity is one of the most common themes on this blog. We like simple software, and we haven't been afraid to write about it in the past. Until recently, I thought I had a pretty good idea of what simplicity was, and why software designers should strive for it, but I've had an awakening.
Before, I thought of simplicity in the same way that most people do. Simple software doesn't have a ton of features. Simple software doesn't try to do too many things. Most importantly, simple software is easy to use. Well I'm writing today to say that I no longer believe that any of these things are true.
Ok, maybe they are true most of the time, but what I mean is that I don't think that any of those things have to be true. They generally are, but all of those qualities are symptoms of simplicity. They don't help us understand what simplicity really is, or why we need it. After all, as I've said before, Twitter is easy to use, but it's also worthless. So should Twitter get credit for being easy to use even though most people don't understand why you should use it in the first place?
By traditional standards, the most simple software in the world would be a blank screen. You launch the software, your screen goes black, and you're done. It's incredibly easy to use. There aren't any unnecessary features. It's simplicity at its finest. But for some reason I don't think many people would enjoy using software that doesn't actually do anything.
This helps us understand the true importance of simplicity in software. Software doesn't have any intrinsic value. Most of us don't like software itself. We like what software can help us accomplish. So my argument is that we don't directly care if software is easy to use, we only care if our lives are easier as the result of the software we use.
Like I said earlier, a common symptom of this new definition of simplicity is that simple software ends up being easy to use. This seems obvious because if the point of simplicity is to make your life easier, and part of your life is spent using software, then easier software leads to an easier life. All else being equal, easy software = simple software. But let's throw a wrinkle into that idea.
For the sake of this conversation, lets say that you can measure difficulty on a scale from 1 to 10. Really easy software is a 1, and Adobe Photoshop is a 10. Now lets say that some made up person named Bob currently uses two different applications that both have difficulty 5. What if the first application could add all the functionality of the second application, but that would move it up to difficulty 6? Would that application become less simple because it's more difficult to use? I would argue that as far as Bob is concerned, the first software would be even more simple, because his life is made easier now that he only has to use a difficulty 6 application instead of two difficulty 5 applications. So by adding tons of features and becoming harder to use, software can potentially become more simple in the eyes of a user.
But what if Bob is the only person alive that used both of the applications? While the software may be more simple to Bob, it becomes more complex for everyone else because functionality was added that they don't need. It's clear that this new definition of simplicity is entirely relative, and pretty complicated.
So what is a software company to do? There's obviously no clear answer to that question, but I am personally reconsidering how I approach software design. I still hate unnecessary features. I still want every feature I build to be as easy to use as possible. But now when I consider what projects I should be working on, I'm thinking about the user and not my software.
For example, at Less Annoying Software, virtually all of our customers use some sort of calendar application (Outlook, gCal, etc.) in addition to our software. Adding a full-blown calendar app to LAS would almost certainly make it more complex, but it would also mean that our users would have one less thing to check everyday. A few months ago I would have hated the idea of a calendar because it would make LAS harder to use, but now I realize that it might end up making our users' lives easier overall which is far more important.
You shouldn't take this to mean that we're going to start adding a ton of features to Less Annoying Software. We'll still be just as selective when deciding what to add, and we'll still try to implement every feature in the least disruptive way possible. But now we're approaching our decision making in a fundamentally different way. Our software doesn't matter anymore. Only our users' happiness matters. We're going to do what we can to optimize happiness and whatever happens to the software is just a symptom of true simplicity.