Some summers ago, I was fishing on a pier with my cousin, who at the time was studying to be a mechanical engineer. He was gazing at a series of tires that were equidistantly attached along the pier. He was looking so intently that I just had to ask: “what’s so interesting about those tires?”
“They’re so simple,” he mused, “if I were asked to design that, it would have hydraulics.”
If you consider examples of what people usually think of as design—say architectural or graphic—one of the things you notice is that as the product of that process gets better, the simpler it becomes. It becomes simpler because each revision removes the parts that do not directly embody the ideas that the designer wishes to express. I’ll even go as far as saying that simplicity is the main goal of design. As the poet Alexander Pope once said about sculpture: “I choose a block of marble and chop off whatever I don’t need.”
The scientific world provides us with a concept called “Occam’s razor”. It states that given two equally valid explanations for a phenomenon, the simpler one is probably the correct one. It’s not strange that both science and design share this concept. The scientific process is, after all, a design activity that invents theories—sometimes really wild ones—and then tests them to see if they hold water.
K.I.S.S., Occam’s razor. However you want to put it, simple is better, and better means simpler. Even Leonardo da Vinci said: “Simplicity is the ultimate form of sophistication.”
It’s curious then that software tends to become more complex over time. Software development, like the scientific process, is a form of design. So shouldn’t better software mean simpler software?
The paradox—if I haven’t already made it obvious—is that developers tend to add features to their software over time, even though the additions increase complexity.
Exacerbating the problem is the fact that software developers need to make money. They must supply their users with the motivation to buy upgraded version of their software. This motivation spurs the addition of new features. As software ages, features are invariably added that do not have anything to do with the solution that the software was originally intended to provide.
Sometimes the software attempts to remedy a problem that is poorly defined. Software developers end up over-generalizing features to ensure that they have covered all the bases. This doesn’t always happen due to developer negligence; many times the developer simply doesn’t know that he’s dealing with many problems masquerading as one.
So, how can the software industry fit in with the rest of the design world, where better means simpler?
One naive approach is to refuse to add new features, or to remove features that users do not find useful. But how do you determine when a feature is not useful? I may have no use for a feature that you absolutely depend on. For example, we can all probably agree that Microsoft Word would be better off simplified. However, I bet we would argue for days about exactly which features should be removed.
Once users come to depend on a feature, misguidedly added or not, you can’t remove it. Paul Graham, in his book “Hackers & Painters” writes: “When you make any tool, people use it in ways you didn’t intend […]”
Simply stated, the real barrier to simplifying software is that it always ends up having too many users whose usage of the software is too vaguely defined. Asking which features to remove is the wrong question. The right question is: how do you give users the features they want and make the software simpler?
A possible solution to this seemingly intractable problem occurred to me while listening to a speech given by Malcolm Gladwell at a TED conference. Malcolm, the author of “The Tipping Point” and “Blink”, recounts the story of Howard Moskowitz, whom he credits with reinventing how the commercial food industry thinks about its products.
As Gladwell tells it, Moskowitz was contracting with Pepsi to discover the perfect amount of sweetness for their new Diet Pepsi product. What he discovered was that there was no perfect amount of sweetener that appeased the majority of people. So, instead of recommending to Pepsi that they just average some numbers and use that as a basis for their one perfect product, he told them that they couldn’t have just one product. Gladwell paraphrases Moskowitz: “You don't need a Pepsi, he argued, you need Pepsis.”
Moskowitz went on to discover that this exact same principle applied to other food products, including pickles and pasta sauces.
The core of his discovery is that of horizontal segmentation. It is the realization that there isn’t a single product that meets everyone’s needs, but instead several. When you go to the store and are confronted with thirty six different pasta sauces, that’s Moskowitz’s work. Gladwell says, paraphrasing Moskowitz:
“When we pursue universal principles in food, we aren’t just making an error, we are actually doing ourselves a massive disservice.”
Further, Gladwell states himself:
“[…] it is the movement from the search of universals to the understanding of variability. [For example] now in medical science we don’t want to know how necessarily just how cancer works, we want to know how your cancer is different from my cancer.”
Striving for universality in all things is not always appropriate. Sometimes, how we are different is much more interesting. The lesson to be gleaned from Howard Moskowitz is that it is better to be all things to a few people than it is to be a few things to all people.
Applying this principle to Microsoft Word, instead of one application used for everything from web page generation to flyer creation, perhaps it should do just one thing well: word processing. What do you do with the other functionality? Put them in a different application—perhaps a completely new one. An application specifically suited for web publishing. An application suited to create flyers.
You could even take the concept a step further and realize that there isn’t just one kind of writer, but many, each with their own ways of doing things. Not all of Word’s features are appropriate for all writers. Indeed, one important feature of Word may no longer even be relevant to many of them: “what you see is what you get”, better known by its abbreviation, WYSIWYG. Could it be that this feature can be removed?
WYSIWYG was originated by a newsletter published by Arlene and Jose Ramos in the late 1970s, and its intent was to simulate on the screen how a document would look on its final output device. For the majority of the 80s—and a lot of the 90s—the final output device was some form of printer or electronic typesetter. In other words, the output medium was paper.
What’s interesting is that in recent years, the majority of what is typed is no longer intended for print. Some of it ends up as web pages. The majority of it is transmitted as email.
Take this essay, for example. At no time did I ever intend for it to end up on paper. It was intended to be posted on this blog. You might argue that the “output device” in this case is this blog, and therefore the spirit of WYSIWYG would have my word processor depicting this text exactly as it would appear as posted. However, this would only help to prove my point: because it targets paper as its output medium, Word is not the appropriate tool for me.
Perhaps several word processors are called for, instead of a single do-it-all word processor. In fact, such word processors already exist. Your email program is a word processor specifically geared to writing emails. There exists word processors for writing blog posts. If you write scripts, you’re familiar with Final Draft, a word processor specifically for writing scripts.
Simplicity in software can be achieved by allowing for, at design time, the possibility that the application being designed is actually two applications. It is achieved by realizing that a new feature may actually be the first feature of a new application.
In the future, software that targets specific users will become the norm, and behemoths such as Word will fade away.
If I were Howard Moskowitz, I might say that we don’t need a word processor. We need word processors. Word processors that are diverse, and above all, simple.
As an alternative spin on it, perhaps it's a possibility to have a product that reconfigures?
To give an example, I do a wide variety of text editing. Some of it will be cleaning up garbage HTML I'm given to work on. (This is an instance where WYSIWYG needs to simply shape up or die!) Some of it will be new coding. Some will be creative writing, some will be e-mail, etc etc.
I use TextMate for every bit of it, not because it's all things but because it can become what it needs to be.
Simplicity does not necessarily preclude complex results. As an example, look at the dragon curve: you can make this thing by simply folding and unfolding a strip of paper in a very straightforward way, and yet it's the most stunning, complex, and beautiful mathematical form I've seen.
Put another way: simplicity is best when it's narrow depth rather than breadth. A small feature-set, certainly, but widely applicable.
Getting it right is hard.
Posted by: Rob Rix | 19.01.2007 at 16:14