A few months ago someone asked me why her mobile device could automatically open an email attachment, but her desktop computer could not. Her desktop operating system (OS) told her the file type could not be recognized. The attachment is a document for a popular office suite created by the same company as her OS. Not only did the OS not understand the common document, it failed to point her to an available solution (a reader made by the same company.) This is not just a failing of the OS or software company, this is an embarrassment to the entire software world.


Long ago (4+ decades) smart people thought about how best to interface with computers. Resources were limited, but imaginations came in great supply. The GUI (Graphic User Interface) concept (see “History of the GUI” at Ars Technica) appeared in the 1960s. Other ideas were about software design (flexibility, maintainability, and extensibility) including other programming concepts. Key results included that users should not need understand computer technology.

Software should simplify tasks and deliver a positive user experience. Bring the user closer to their data. IBM lists seventeen design goals and David Hooker lists seven, but I focus on four. The rest fall in line.

  • Keep it simple, stupid (KISS.)
  • High visual communication; no clutter.
  • Maintain common actions; don’t surprise the user.
  • Stay focused on the goal. Some problems are moving targets.

Adhering to these goals allows the consumer to reach their goal by using the best tool for the job. Consumers sometimes end up using software differently than intended, because the designer didn’t completely understand the problem or the problem changes over time. These four primary goals live on after the product is finished.

In the beginning (1980s,) personal computers achieved these goals, more or less. Technology was limited for better and worse. Computers limited in abilities made some tasks difficult, but tiny resources (memory and CPU) also kept software design in check. This forced programmers to focus on simple tasks. My favorite word processor born in the 1980s died in the early 1990s, even though new versions continue on like scary ghosts haunting the computer world. Today’s version has many more features, but doesn’t process words any better. And does it much slower on faster machines.

How Software Designers Have Failed

Today when I listen to common consumers, I hear more concern about technical aspects than about experience. Consumers argue about “gigabytes” and “gigahertz.” They are concerned about how to carry all their videos, pictures, and other creations around. They demand disk space and adapters. Consumers brag about the number of triangles per second their video card can push. What does the number matter if it results in poor video or terrible overall performance? They beg for features, some of which they rarely ever use or duplicate abilities in better performing products.

What’s wrong with this picture? A consumer should never need worry about x number of features, disk space, or how a file system works. The consumer should be more concerned about getting their work done using the best tool for each job.

Part of the problem is the explosion in hardware advancement during the 1990s leading to faster and cheaper processors, memory, and storage. Software designers are lazy. Without resource limitations, many programmers don’t worry about using too much memory or looking for more efficient algorithms. The mantra: computers have more than enough, just get the program done.

Marketers are lazy, too. It is much easier to market numbers: GHz, GBs, number of adapters on the hardware side, and x number of features or all-in-one solutions on the software side. You can’t put a number on experience.

Overall, the software world has gone backwards leading to cluttered products full of afterthought features, difficult to navigate menus, slow performance reducing our work flows and degrading our experiences.

Mobile Computer Revolution Failure

Advancement in tiny technology has given birth to phones more powerful than desktop computers of past decades. Like the computers of the 1980s and early 1990s, memory and processor power are (were) limited. This results in refined software.

However, many software designers misinterpret “maintain common actions” as familiarity. Some phones try using menus or actions like their PC cousins, but on a tiny screens resulting in clumsy operation. Many users happily navigate this familiar nightmare until they try another device that does it so much better. But the designers aren’t completely wrong about familiarity. Even worse is introducing something so radical that consumers run away.

Consumers don’t know what they want. It’s like the Simpsons episode where the car manufacturer asks Homer what he wants in the perfect car. Homer asks for bubble domes, fins, and multiple horns—more features—little about improving the driving experience. New ideas are unfamiliar, and too many changes turns into an Edsel.

More power for mobile devices leads to designers implementing the same failures of their desktop counterparts. Manufacturers market number of features, processor speeds, ports, and other bullet points meaningless to the experience. Like Homer Simpson, consumers demand features. And software designers deliver at the cost of usability.

Apple Inc products aren’t perfect, but the genius behind their design is in small iterations of familiar concepts while maintaining a focus on the user experience.

Software Design Back On Track

There are complaints about Apple controlling their App Store and holding developers inside a “walled garden,” but there is an advantage: it helps keep design on track. Design needs to get back to basics through education, collaboration, and putting the end user first.

Consumers have become so entrenched in poor design and feature creatures that great user experiences may take time. Here are my four tips to help achieve the four primary design goals:

  • Assume resources are limited. And often are given a multitasking world.
  • Solve one problem.
  • Familiar buttons, icons, actions should stay familiar.
  • Carefully consider new actions and visuals, collaborate with others to establish, and be willing to modify or abandon for other ideas.
  • Work with other software to help the user create a work flow without the user having to understand file systems.
  • Use, and love using, your own software. Then make it better.

A word processor should be amazingly good at its job, and not try to tackle the problem of laying out content for digital magazines or the web. A layout program should make arranging content for digital magazines amazingly simple, and not have to worry about editing photos or processing words. A person should be able to open an email attachment containing common, well established, data in the right solution without knowledge of the data file.

My dream is a software revolution bringing users closer to their data, opening a stream from imagination into reality. The same thing designers dreamed about in the ancient times (1950s.)