CHAPTER 17: Designing for the Web – User Interface Design for Programmers

Designing for
the Web

The Web is an incredibly diverse medium. It's impossible to provide hard-and-fast rules that apply equally to a toy store, a movie site, a newspaper, a graphic designer's portfolio, a teenager's journal, and the IBM full-text database of all patents issued since 1971. Many of the books about Web usability seem to assume you're making a corporate site or an e-commerce site. So they are full of rules like "Flash is Bad!" which are just too single-minded to possibly be correct for the wide variety of Web sites out there.

All the principles I've talked about up until now are just as important when you're designing Web sites. Your Web site will be usable if the user model matches the program model. For example, almost every Web site has a little logo in the top left corner, and when you click it, it almost always takes you to the home page. This is so common that people have come to expect it. That's the user model. If your Web site has a logo in the top left corner, and clicking on the logo doesn't do anything, people are going to have trouble using your site. The user model says that things that are blue and underlined are links. If your graphic designers think that underlines look ugly, and they don't underline the links on your site, people won't click. Bonk.

But there are two specific problems you have to watch out for when you design for the Web: time delay and the limitations of HTML.

On the Web, Nobody Knows You're on the Moon

One of the biggest restrictions in designing for the Web is another time-travel problem like the ones discussed in Chapter 14. On the Web, the problem is time delay, also known as lag. When you talk to a user through the Web, it takes them a long time to hear you. Several things conspire to create the slow response time of the Web: slow modem speeds, slow servers, and general Internet latency. Really, really fast pages under optimal conditions might load in a couple of seconds, but in many cases, pages can take fifteen seconds to a minute (or even more) to appear. Your users, for all intents and purposes, are on the moon.

Think of a Web application like, for example, the New York Times. You've got a page with a bunch of headlines. When you click on a headline, a new page loads where you can read the entire story. If reading each story takes ninety seconds, and pages take ten seconds to appear, you are spending 90% of your time reading, which is pretty decent.

In an effort to move up in the Web ratings, the New York Times recently started splitting up each article into two or more Web pages. Hmmm. Now we're spending around 80% of our time reading, which is a little bit less usable.

But wait, it can get worse. As soon as you're developing an application for the Web, as opposed to merely a newspaper or content-based site, things get really clunky. HTML was designed for simple interactions. "Show me this page. Now show me that page. Oops. That's not what I meant, take me back to where I was before." As soon as the interactions get more complicated, HTML starts to look like pretty thin soup. Here's an example. is a pretty neat service that I've been using to print the business cards for my consulting company. You can design your business cards over the Web, and when you're done, they print them and mail them to you. Using the interactive designer, you can add text, move things around, change fonts, add logos, and so forth. Every time you try to do something like move the logo a smidgen to the left, it requires a round-trip to the Web server, which, today, is taking me about half a minute. As you edit the business card, you spend about two seconds thinking about what to do next, and then half a minute waiting for the result, which means you spend more than 90% of your time waiting. This can get kind of frustrating. It's especially frustrating when you're trying to "tweak" the sizes and positions of objects (see Figure 17-1). Don't get me wrong; the designers of have done a heroic job of trying to work within the limitations of HTML, but designing business cards this way is just too dang painful compared to using, say, a thirteen-year-old copy of MacPaint.


Whatever happened to click and drag? Moving something around on screen is the perfect application for a mouse, but it's basically impossible using HTML.

Web interfaces that make you spend so much time waiting just feel clunky, like an old one-speed bicycle with some teeth missing from the gear. At an emotional level, when you get results immediately, you are happy because you feel like you're in control. When you have to wait, you become unhappy. If you have to wait twenty-three times to make a business card, the unhappiness will start to accrue.

A better technology for creating complicated UIs like this might be to use Dynamic HTML or Java Applets. At the very least, your users can lay things out on the screen using a point-and-click interface that responds immediately. Many Web designers have given up on Java Applets for mission-critical work because of the long downloads, the compatibility problems that make it "write once, debug everywhere," and the fact that Java UIs look kind of weird, they don't match the operating system UI exactly. Dynamic HTML has even worse compatibility problems. This is one of those hard trade-offs you always have to make as a designer. Sigh.

Here's another example of the time delay problem: email software. A common activity in managing your email is deleting messages. Some days, all I really have time to do is delete messages. Every couple of weeks, 7,326 messages have accumulated in my inbox, and I need to prune away, at the very least, the stupidest of the jokes that were forwarded to me and the "opportunities" to erase credit card debt or unsightly blemishes.

With a Windows email program like Eudora or Outlook, selecting a message and deleting it can be done virtually instantaneously. Click the mouse, press the Del key, all done! So picking 34 messages from your inbox and deleting them all is quite easy and not unpleasant. (Except on those odd occasions when certain email programs, for some inexplicable reason, decide to potchke around reindexing their files, so the delete operation takes six hours and displays a progress indicator. But that's rare.)

When you're using a Web-based email system like Hotmail, that message about Microsoft buying Norway is stored away on a server. So when you delete it, a message has to be sent to the Web server, which is probably pretty busy delivering spam to a few million people. Eventually the server gets around to processing your request and deleting the message, but then the server has to requery the database to see what messages you still have left in your inbox, construct a new HTML page with the shorter list, stick a flashing-monkeys ad on the top, and send it all back to you over the Internet and a modem that's advertised as 56K but which really never really connects any faster than 43K (those crooks!).

Anyhow, the end result is that a single delete operation takes thirty seconds of user time, not zero seconds. It wouldn't be the end of the world if you were just deleting one message. But we're deleting 34 messages, remember? Which now theoretically takes seventeen minutes, but it probably takes a lot longer, because while you were waiting for the fourth message to be deleted, the cat jumped up on your desk and spilled a cup of hot tea and ran away in fright, and now you have to decide whether to chase the cat and mollify her, or get some paper towels to wipe up the tea before it ruins another keyboard. Frustrating, huh?

Most designers of email-on-the-Web interfaces are aware of this time lag, and they've compensated for it by putting little checkboxes next to each message (see Figure 17-2). You can check off a bunch of messages and delete them all at once. That's a pretty good way to reduce frustration. Although it's not the most intuitive thing in the world, it sure is better than nothing. We're working in a difficult medium here, and we'll take anything we can get. In general, a good rule for Web services is:


A good example of reducing round-trips: Web-based email providers usually give you little checkboxes so you can delete a bunch of messages with one round-trip to the server.

On the Web, every click results in a round-
trip to the server, which reduces usability.
Design to minimize round-trips.

Another example of this rule can be seen in Web discussion sites. There are lots of different interfaces for discussion groups on the Web, but they basically fall into two categories: the type of interface that shows you one message per page (like The Motley Fool or Yahoo! Finance), and the type of interface that shows you a whole bunch of messages all on one page (like, famous for its highly usable, if not learnable, discussion interface).

If you were actually reading up until now, as opposed to daydreaming about something more interesting like Ultimate Frisbee, you should be able to figure out which one I think is better. Even though Yahoo! has a super fast Web server, when you try to read discussions on Yahoo!, you spend a lot of time waiting for the next message to arrive and then getting frustrated when it turns out to be moronic. But when you try to read discussions on Slashdot, all you have to do is scroll down through a long Web page; it's much more fluid, there is no waiting, and you can skip over morons as fast as you can move your eyeball. Within a few minutes you know that everything posted up there is moronic and you can just go play Ultimate Frisbee before it gets dark.

The single-page discussion UI probably exists because those sites are supported by ads, and the more pages you look at, the more ads they can try to show you. Not that you'll care. If you're actually following a discussion, you are not going to look at the ads. If you track the pupils of someone following a discussion, I'll bet that they never once look anywhere near the ad banner as they flip from message to message in the discussion group. The banner could contain a row of flashing orange naked monkeys offering you fifty thousand dollars in actual United States cash if you would just click here, but nobody would notice. It doesn't matter, because those sites get paid for every ad they show you, and they are generally happy to ruin their user interfaces if it means a few more advertiser dollars.

HTML Is Not a Windowing System

The next big limitation of the Web is that Web pages just can't do everything that you can do with a modern, state-of-the-art windowing system, or even with an utterly obsolete windowing system, say, the original Macintosh from 1984. There are just too many things that you can't do.

Menus are one example. Suppose you have a Web site which serves customers in several countries. On the home page, you would like to have a link to the specific site for each country where you do business. For a large company, that could be eighty countries. There's just not enough room to have a link to each of them.

Well, you could have a link on the home page that says "Worldwide Sites," which goes to another page with links for every country. This requires two clicks just to get into the site, which is going to cost you a lot of visitors who just get fed up and click away to to look at cuties.

A more common approach is to try to create a dropdown menu. A dropdown menu is the Murphy Bed of GUIs. It's a real-estate gimmick to fit a lot of stuff into a little space. Unfortunately, HTML doesn't have dropdown menus. The feature just doesn't exist.

There are two common ways Web designers try to work around the lack of menus.

The first is by constructing some kind of JavaScript/Dynamic HTML menu-like thing. That works OK, but it's not terrific, because not all Web browsers support JavaScript and Dynamic HTML, and when they do, the implementations are usually buggy enough that every incremental release of every browser is likely to break your script. Not only that, but when you are done, your carefully created menu probably does not work in exactly the same way as a regular menu. The dropdown menus on Microsoft's current home page are really more like fall-down menus that plop down if you even move your mouse over them. In Windows itself, the menus won't drop down unless you click on them. The lack of consistency, as I have hopefully drilled into you by now, can create usability problems.

A slightly easier way to provide menus in a Web page is by using a dropdown listbox, which sort of looks like it might be a menu, but, um, no, it's not a menu. It is visually different (see Figure 17-3). It doesn't behave like a menu. In GUI apps, there has been a long-standing rule that changing an item on a dropdown should not take any major action like navigating. It is only supposed to be used to change a setting. You still have to press an OK button to take the action. One good reason that this rule exists is that dropdown listboxes require a lot of mouse-dexterity (see Chapter 10), and as you know, people can't use the mouse.


Using dropdown listboxes for menus is inconsistent and confusing.

Many clever Web designers have realized that by using JavaScript, you can detect when the user has changed the contents of the dropdown. So they make a dropdown which actually navigates for you as soon as you choose something. This is almost always a bad UI. When the user makes a mistake and selects the wrong item, which is quite common, they will find themselves navigated to a new page. And they will be surprised by this, too, because the GUI convention for dropdown listboxes is that they don't take any action. Whenever you surprise people, you are by definition making a bad UI choice. If the user lets go of the mouse button on the wrong choice and the page flips right away, they will have to back up and start over. Frustrating.

Another thing that's really hard to do well in HTML is make a dialog box. Some designers have attempted to simulate dialog boxes by popping up a secondary window. But that's not quite good enough. The secondary window is not a child window of the main browser window, so it doesn't stay on top. If you click back on the main window, the secondary window gets covered up. And the secondary window must load its contents from the Web, which is going to take some time. By now, many people have come to associate secondary windows with ads. Many people will just automatically hit the close box before they even realize you're showing them a dialog box, not an ad. (Leave it to advertisers to spoil it for the rest of us.) Yet again, the limitations of HTML foil our attempts to use common GUI metaphors.

The closest thing you can do to make a dialog box is simply to navigate to another page with a form on it. That's not quite as good as a real live dialog box. Why? Well, a dialog box pops up on a window above your work, which is a real-world metaphor that gives people confidence that their original work hasn't gone away, it has merely been interrupted. Without overlapping windows, people lose their bearings and forget where they are and how they got there. But for now, it will have to do.

Yet another thing you can't do on the Web is provide a decent text-editing widget. The best you can do is put up a big TEXTAREA, which is about as user-friendly as Windows' Notepad without the Save command. When you're composing a really long email to your Aunt Marge with Hotmail, there's no way to save your work regularly. So if you accidentally close the Web browser, the entire three-page story about how the neighbor's ferret got into your grape pie is just lost. This doesn't happen with regular email programs which have a Save command and which don't let you close windows without prompting you to save.

Use the Web Browser's UI

Let's think for a minute about what makes a Web browser so easy to use in the first place. It only has a three interface features you need to learn about to be productive:

  1. Clicking on a link
  2. Scrolling
  3. Clicking on the Back button (optional)

A very distant fourth is filling out forms, so you can order Harry Potter books from Almost everything else in the UI is fluff. That's why Web browsers are so easy to use.

Historical Note

Some early Web usability gurus did some usability tests and discovered that people don't know how to scroll. What they failed to notice was how quickly people learn this skill. Once again, they confused usability with learnability. In the meantime, an uncanny amount of damage has been done by Web site designers who try to cram their sites into a tiny rectangle so that their site is viewable without scrolling, usually by using a font so small most people have to strain to read it. Luckily, the "nobody knows how to scroll" superstition is wearing off.

One assumption we've been making all along is that when you make a Web site, you have to design a UI for it. But the interesting thing is that almost anything you can do to avoid designing a UI is probably going to improve the usability of your site. If you rely on links instead of making a funny dropdown navigator, all the people whose brains are only just large enough to remember those three primary interface features will still be able to use your site.

One thing sort of amusing about this is that it seems to be a general rule that the fewer nifty features you use, the more usable your site will be, because people have already figured out the default Web browser UI:

  • If you don't change the color used to display links, the Web browser's defaults will apply. These defaults provide a different color for visited and unvisited links. So, people will be able to see at a glance which parts of your site they've visited, making it easier to scan through and avoid reading things twice.
  • If you don't use GIF images for buttons, but just use buttons instead, your buttons will look the same as all the other buttons on the Web and people will realize that they can push them.
  • If you don't use funny redirects, you won't break the Back button on Web browsers and people will be able to back out of your site.
  • If you don't use Flash or Shockwave for your content, Web search engines will be able to index your site, so people searching for your site will find it. If you use a cool Flash animation for all your press releases, your press releases will not be available to search engines and fewer people will find them.
  • If you don't use frames, people will be able to create shortcuts to any page on your site. They will be able to cut and paste the URL from the address bar into an email message. If you use frames, the address bar doesn't necessarily change to reflect the current frame contents.

These are just a few examples of how limiting yourself to the most basic features of HTML can make Web sites more usable. Basically, the Web evolved a little too quickly. All the neat features that were added since the earliest versions of HTML weren't really deeply integrated into the structure of the Web, so today they are not universally available and they are not universally understood. Flash and Java applets are some of the worst offenders, because they create a rectangle of lawlessness, inside of which every designer has to reinvent the user interface from the ground up, something which is rarely done in a consistent way.

Bottom line:

The fewer cool Web features you use, the
more usable your site will be.

Please don't let this stop you if you are making a site that's meant to be entertaining rather than useful. Usability is not everything. If usability engineers designed a nightclub, it would be clean, quiet, brightly lit, with lots of places to sit down, plenty of bartenders, menus written in 18-point sans serif, and easy-to-find bathrooms. But nobody would be there. They would all be down the street at Coyote Ugly pouring beer on each other.