agrclassic.com

The popular choice is the best user model, and it’s up to you to make the program modelmatch it.

The next step is to test your theories. Build a model or prototype of your user interface and give some people tasks to accomplish. The model can be extremely simple: sometimes it’s enough to draw a sloppy picture of the user interface on a piece of paper and walk around the office asking people how they would accomplish x with the “program” you drew.

As they work through the tasks, ask them what they think is happening. Your goal is to figure out what they expect. If the task is to “insert a picture,” and you see that they are trying to drag the picture into your program, you’ll realize that you had better support drag and drop. If they go to the Insert menu, you’ll realize that you had better have a Picture choice in the Insert menu. If they go to the Font toolbar and replace the word “Times New Roman” with the words “Insert Picture”, you’ve found one of those old relics who hasn’t been introduced to GUIs yet and is expecting a command-line interface.

How many users do you need to test your interface on? The scientific approach seems like it would be “the more, the better.” If testing on five users is good, testing on twenty users is better!

But that approach is flat-out wrong. Almost everybody who does usability testing for a living agrees that five or six users is all you need. After that, you start seeing the same results again and again, and any additional users are just a waste of time. The reason being that you don’t particularly care about the exact numerical statistics of failure. You simply want to discover what “most people” think.

You don’t need a formal usability lab, and you don’t really need to bring in users “off the street”—you can do “fifty-cent usability tests” where you simply grab the next person you see and ask them to try a quick usability test. Make sure you don’t spill the beans and tell them how to do things. Ask them to think out loud and interview them using open questions to try to discover their mental model.

Taken from : User Interface Design for Programmers

This turns out to be relatively easy. Just ask some users! Pick five random people in your office, or friends, or family, and tell them what your program does in general terms (”it’s a program for making Web pages”). Then describe the situation: “You’ve got a Web page that you’re working on and a picture file named Picture.JPG. You insert the picture into your Web page.” Then ask them some questions to try and guess their user model. “Where did the picture go? If you delete the Picture.JPG file, will the Web page still be able to show the picture?”

A friend of mine is working on a photo album application. After you insert your photos, the application shows you a bunch of thumbnails: wee copies of each picture. Now, generating these thumbnails takes a long time, especially if you have a lot of pictures, so he wants to store the thumbnails on the hard drive somewhere so that they only have to be generated once. There are a lot of ways he could do this. They could all be stored in one large file called Thumbnails in someplace annoying like C:\. They could all be stored in separate files in a subdirectory called Thumbnails. They might be marked as hidden files in the operating system so that users don’t know about them. My friend chose one way of doing it that he thought was the best tradeoff: he stored the thumbnail of each picture, picture.JPG, in a new file named picture_t.JPG within the same directory. If you made an album with thirty pictures, when you were finished, there would be sixty files in the directory including the thumbnails!

You could argue for weeks about the merits and demerits of various picture-storing schemes, but as it turns out, there’s a more scientific way to do it. Just ask a bunch of users where they think the thumbnails are going to be stored. Of course, many of them won’t know or won’t care, or they won’t have thought about this. But if you ask a lot of people, you’ll start to see some kind of consensus. As it turns out, not very many people expected the picture_t.JPG file, so he changed the program to create a Thumbnails subdirectory.

Taken from : User Interface Design for Programmers

Let’s look at another example. In Microsoft Word (and most word processors), when you put a picture in your document, the picture is actually embedded in the same file as the document itself. You can create the picture, drag it into the document, then delete the original picture file, but the picture will still remain in the document.

Now, HTML doesn’t let you do this. HTML documents must store their pictures in a separate file. If you take a user who is used to word processors and doesn’t know anything about HTML, then sit them down in front of a nice WYSIWYG HTML editor like Microsoft FrontPage, they will almost certainly think that the picture is going to be stored in the file. Call this user model inertia, if you will.

So, we have an unhappy conflict of user model (the picture will be embedded) versus program model (the picture must be in a separate file), and the UI is bound to cause problems.

If you’re designing a program like FrontPage, you’ve just found your first UI problem. You can’t really change HTML; after all, it’s an international standard. Something has to give to bring the program model in line with the user model.

You have a couple of choices. You can try to change the user model. This turns out to be remarkably hard. You could explain things in the manual, but everybody knows that users don’t read manuals, and they probably shouldn’t have to. Or, you can pop up a little dialog box explaining that the image file won’t be embedded—but this has two problems: it’s annoying to sophisticated users; and users don’t read dialog boxes, either. We’ll talk more about this in Chapter 9.

So, if the mountain won’t come to Muhammad, Muhammad must go to the mountain. Your best choice is almost always going to be to change the program model, not the user model. Perhaps when the user inserts picture, the program should make a copy of the picture in a subdirectory beneath the documentfile—this, at least, conforms to the user’s idea that the picture is copied (and the original can safely be deleted).

Taken from : User Interface Design for Programmers

Overview

When I was in college many years ago, a friend of mine down the hall pulled an all-nighter. A critical term paper was due the next day, and he stayed up until 6 A.M. banging away on hisMacintosh. Finally, bleary-eyed, he turned off the computer and tried to catch a couple of hours of sleep before the paper was due.

Yep.

He turned off the computer.

Notice I didn’t say that he saved his work and turned off the computer. At 6 A.M., he forgot about that little thing.

At about 7:45 A.M., he came knocking on my dorm room door in despair. “Um, you know computers,” he was practically crying. “Can’t I get my paper back?”

“You didn’t save it at all?” I asked.

“Nope.”

“Never? All night long you never once hit ‘Save?’”

“No. It was still called ‘Untitled.’ But it’s in there somewhere, isn’t it?”

The Macintosh in its WYSIWYG glory simulates the act of typing on a piece of paper so perfectly that nothing interfered with my friend’s sad idea that his paper was in there, somewhere. When you write on a piece of paper, that’s it! Done! The paper is now written.

There’s no Save operation for paper.

A new user who sits down to use a program does not come with a completely blank slate. They have some expectations of how they think the program is going to work. This is called the user model: it is their mental understanding of what the program will do for them.

If they’ve never used a computer before, and the computer shows them what looks like a piece of paper and lets them type on it, then they are completely justified in assuming that they won’t need to save their work.

Experienced users have user models, too: if they’ve used similar software before, they will assume it’s going to work like that other software. If you’ve used WordPerfect but not Word, when you sit down to use Word, you assume that you must save.

The program, too, has a model, only this one is encoded in bits and will be faithfully executed by the CPU. This is called the program model, and it is The Law. Nothing short of electrical storms and cosmic rays can convince a CPU to disobey the program model.

Now, remember the cardinal axiom from Chapter 1? You should have memorized it by now:

A user interface is well designed when the program behaves exactly how the user thought it would.

Another way of saying this is:

A user interface is well designed when the program model conforms to the user model.

That’s it. Almost all good user interface design comes down to bringing the program model and the user model in line. The Macintosh UI would have been more successful (especially for my poor friend) if it saved your “unsaved” work for you. Of course, in 1985, the slow speed of floppy disks made this impractical. But in 1988, by which time everybody had hard drives, this became inexcusable. To this day, most popular software doesn’t automatically save your work.

Taken from : User Interface Design for Programmers

Most flame wars you read about user interface issues focus on the wrong thing. Windows is better because it gives you more ways to resize the window. So what? That’s missing the point. The point is, does the UI respond to the user in the way in which the user expected it to respond? If it didn’t, the user is going to feel helpless and out of control, the same way I felt when the wheels of the dough-bathtub didn’t turn the way I pushed them, and I bumped into a wall. Bonk.

UI is important because it affects the feelings, the emotions, and the mood of your users. If the UI is wrong and the user feels like they can’t control your software, they literally won’t be happy and they’ll blame it on your software. If the UI is smart and things work the way the user expected them to work, they will be cheerful as they manage to accomplish small goals. Hey! I ripped a CD! It just worked! Nice software!!

To make people happy, you have to let them feel like they are in control of their environment. To do this, you need to correctly interpret their actions. The interface needs to behave in the way they expect it to behave.

Thus, the cardinal axiom of all user interface design:

A user interface is well designed when the program behaves exactly how the user thought it would.

As Hillel said, everything else is commentary. All the other rules of good UI design are just corollaries.

Taken from : User Interface Design for Programmers

On Windows, when a message box pops up, you can hit Enter or the space bar to dismiss the message box. On the Mac, space doesn’t work. You usually need to click with the mouse. When Pete got alerts, he tried to dismiss them using the space bar like he’s been doing subconsciously for the last six years. The first time, nothing happened. Without even being aware of it, Pete banged the space bar harder since he thought that the problem must be that the Mac did not register his tapping the space bar. Actually, it did—but it didn’t care! Eventually he used the mouse. Another tiny frustration.

Pete has also learned to use Alt+F4 to close windows. On the Mac, this actually changes the volume of the speakers. At one point, Pete wanted to click on the Internet Explorer icon on the desktop, which was partially covered by another window. So he hit Alt+F4 to close the window and immediately double-clicked where the icon would have been. The Alt+F4 raised the volume on the computer and didn’t close the window, so his double click actually went to the Help button in the toolbar on the window (which he wanted closed anyway), and that started bringing up a help window, painfully slowly, so now he’s got two windows open that he has to close. Another small frustration, but, boy, does it add up.

At the end of the day, Pete is grumpy and angry. When he tries to control things, they don’t respond. The space bar and the Alt+F4 key “don’t work”—for all intents and purposes it’s as if those keys were broken. The window disobeys when he tries to make it wider by playing a little prank: it just moves over instead of widening. Bad window. Even if the whole thing is subconscious, the subtle feeling of being out of control translates into helplessness, which translates into unhappiness. “I like my computer,” Pete says. “I have it all set up so that it works exactly the way I like it. But these Macs are clunky and hard to use. It’s an exercise in frustration. If Apple had been working on MacOS all these years instead of messing around with Newtons, their operating system wouldn’t be such a mess.”

Right, Pete. We know better. His feelings come despite the fact that the Macintosh really is quite easy to use—for Mac users. To close a window, it’s totally arbitrary which key you press. The Microsoft programmers who were, presumably, copying the Mac interface probably thought that they were adding a cool new feature in letting you resize windows by dragging any edge. And the MacOS 8 programmers probably thought that they were adding a cool new feature when they let you move windows by dragging any edge.

Taken from : User Interface Design for Programmers

When you find yourself frustrated, angry, and upset, it’s probably because something happened that you could not control: even something small. The space bar on your keyboard is not working well. When you type, some of the words are stuck together. This gets frustrating, because you are pressing the space bar and nothing is happening. The key to your front door doesn’t work very well. When you try to turn it, it sticks. Another tiny frustration. These things add up; these are the situations that make us unhappy on a day-today basis. Even though they seem too petty to dwell on (I mean, there are people starving in Africa, for heaven’s sake, I can’t get upset about space bars), nonetheless, they change our moods.

Let’s pause for a minute and go back to computers.

We’re going to invent a typical Windows power user named Pete. When you’re thinking about user interfaces, it helps to keep imaginary users in mind. The more realistic the imaginary user is, the better you’ll do in thinking about how they use your product.

Pete is an accountant for a technical publisher who has used Windows for six years at the office and a bit at home. He is fairly competent and technical. He installs his own software; he reads PC Magazine; and he has even programmed some simple Word macros to help the secretaries in his office send invoices. He’s getting a cable modem at home. Pete has never used a Macintosh. “They’re too expensive,” he’ll tell you. “You can get a 733 MHz PC with 128 Meg RAM for the price of…” OK, Pete. We get it.

One day, Pete’s friend Gena asks him for some computer help. Now, Gena has a Macintosh iBook because she loves the translucent boxes. When Pete sits down and tries to use the Macintosh, he quickly becomes frustrated. “I hate these things,” he says. He is finally able to help Gena, but he’s grumpy and unhappy. “The Macintosh has such a clunky user interface.”

Clunky? What’s he talking about? Everybody knows that the Macintosh has an elegant user interface, right? The very paradigm of ease-of-use?

Here’s my analysis of this mystery.

On the Macintosh, when you want to move a window, you can grab any edge with the mouse and move it. On Windows, you must grab the title bar. If you try to grab an edge, the window will be reshaped. When Pete was helping Gena, he tried to widen a window by dragging the right edge. Frustratingly, the whole window moved rather than resizing as he expected.

Taken from : User Interface Design for Programmers

And I started to think about why, as the beer commercial asks, some days are better than others.

One day, thinking about this problem, I noticed that one of the bathtubs-with-wheels had pretty lousywheels that wouldn’t turn well. Sometimes this bathtub did not go where I pushed it, and bumped into things. This was a small frustration. Sometimes, as I was pulling the chain to winch up the bathtub, I scraped myself—just a little bit— on a splinter of metal on the chain. Another small frustration. Sometimes, as I ran with an empty bathtub to catch a dough emission about to fly out of the mixer, I slipped on a little bit of oil on the floor. Not enough to fall, mind you, just a tiny slip producing a tiny frustration.

Other times, I would have tiny victories. I learned to time the dough production perfectly so that fresh dough would arrive just seconds before the previous batch ran out. This guaranteed the freshest dough and made the best bread. Some of the victories were even tinier: I would spot a strawberry-sized blob of dough that had flung off of the mixer and attached itself to the wall, and I would scrape it off with a paint scraper I carried in my back pocket and throw it in the trash. Yes! When slicing the dough into pieces, sometimes it just sliced really nicely and easily. These were tiny moments of satisfaction when I managed to control the world around me, even in the smallest way.

So that’s what days were like. A bunch of tiny frustrations, and a bunch of tiny successes. But they added up. Even something that seems like a tiny, inconsequential frustration affects your mood. Your emotions don’t seem to care about the magnitude of the event, only the quality.

And I started to learn that the days when I was happiest were the days with a lot of small successes and few small frustrations.

Years later, when I got to college, I learned about an important theory of psychology calledLearned Helplessness, developed by Dr. Martin E. P. Seligman. This theory, backed up byyears of research, is that a great deal of depression grows out of a feeling of helplessness: the feeling that you cannot control your environment.

The more you feel that you can control your environment, and that the things you do are actually working, the happier you are.

Taken from : User Interface Design for Programmers

My first real job was in a big industrial bakery that churned out hundreds of thousands of loaves of bread every night. The bakery was designed to have six bread production lines. For every two production lines, there was a dough mixer, which produced these gigantic 180 kg lumps of dough that could be dumped to the left or the right, as shown in Figure 1-1.

Figure 1-1: The bakery, as designed

Well, this was the design. In reality, Mixer C hadn’t been built yet, nor had lines three or five. So the arrangement was more like Figure 1-2.

Figure 1-2: The bakery, as implemented

Alert readers will be wondering, “how did the dough get from Mixer B to production line six?” Well, that’s where Wee Joel came in. My job, if you can believe this, was to stand to the left of Mixer B, then catch these walrus-sized lumps of dough as they flew out of the mixer in a big bathtub with wheels, then roll the bathtub over to production line six, and using a winchlike device, heave the dough onto the line. I had to do this once every ten minutes from about 10 P.M. until 4 A.M.

There were other complications. Line six couldn’t really handle 180 kg of dough all at once, so I had to slice each blob with a giant knife into about ten pieces. I don’t even want to go into how absurdly difficult that was.

The first few days, of course, I was terrible at this job. It seemed nearly impossible. Every bone in my body ached. My blisters had blisters. I had aches in places where I didn’t know I had places.

At first I just couldn’t keep line six supplied with dough. Every time I got behind in supplying the dough, there was a big gap on the assembly line. When the gap rolled into the oven, the oven (expending a constant amount of energy over a reduced amount of dough) started to heat up more, which burnt the bread.

Sometimes line six would get gummed up and stop running, but the mixer went right on ahead producing dough for me and I ran the risk of running out of enough bathtubs-withwheels to store the dough in. When this happened, I had to clean and oil the floor and actually dump the dough onto the floor to be scraped up later. Not that this worked very well, because if the dough got older than about thirty minutes it would ferment into unintentional sourdough. If this happened, you had to chop it up into five kg pieces and put one piece into the mixture for each future batch.

After a week or so, I became good enough at the routine that I actually had, if I remember correctly, two minutes free for every ten-minute dough-cycle to rest. I figured out a precise schedule and learned how to tell the mixer to skip a batch when the production line stopped.

Taken from : User Interface Design for Programmers

It is obvious that such fundamental change requires innovation not just in a firm’s own systems, but also in its whole supply chain. Web-based links need to be formed between both internal departments and suppliers and customers right through the chain. It also means integrating the whole value chain into virtual business communities (Timmers, 1999), virtual value chains (Rayport & Sviolka, 1995), or value nets (Bovet & Martha, 2000) depending on the preferred terminology. Read the rest of this entry »