Shortcuts to Success: Bookmarks


In helping your users get the most out of their time, you can make your program faster to use by helping the users quickly get to what they need. One way to do this is through a bookmark feature.

Not all software, of course, can benefit from bookmarks, but a lot of software can. But to see this, you might need to expand your definition of a bookmark. Here are some sample bookmarks:

  • A recently used file list in the File menu, if your software opens and closes files

  • An easily reachable list of locations within a document if your software supports documents

  • A list of currently open documents under the Window menu

  • A most recently used item in a tool menu, such as a recent filter showing up at the top of a filter menu in a graphics program

  • The most recently used fonts in a font list showing up at the top of the list (Microsoft Word does this.)

  • A set of commonly performed queries in a database application, such as all products with a low inventory or all customers with outstanding payments (not to be confused with an outstanding payment history!)

  • And, of course, the configurable list of favorite websites on the Internet

Of course, you don’t need to limit yourself to just one item in this list; further, you can probably come up with some additional places where the bookmark concept fits in. (And yes, technically we might argue that the bookmark concept is a metaphor, but really now, how many times do we actually think of the little plastic thing with pictures on it used for marking pages in a book?)

When you include your bookmark, however, please include these features:

  • The bookmark clearly identifies the item it refers to, such as which website or which document.

  • The bookmarks are configurable and editable.

  • The bookmarks can be sorted.

  • The user can categorize the bookmarks and create user-defined categories (if there are many bookmarks).

  • The bookmarks save when the program exits and reload when the program starts. (However, please don’t make the user manually load and save the bookmarks!)

In addition, if you are providing your users with a means for a lot of bookmarks, you might want to include these features:

  • Export the bookmarks to a file.

  • Import the bookmarks from a file.

Typically you will want to export the bookmarks as a simple text file. But if you really want to get fancy, you can use XML or HTML. Note that I say “HTML” as one option since that’s what Internet Explorer and Netscape use for exporting their bookmarks. Normally you would use HTML only if you expect the data to be read in a web browser. However, don’t immediately assume that’s crazy. Being able to list your files in a web browser is sometimes handy!

In Internet Explorer, if I bookmark the Yahoo! site, then I will probably want the text that appears on the menu to be “Yahoo!” But the data underneath the menu will be http://www.yahoo.com. If you follow this approach, then that means your users can do the following:

  • Choose the bookmark based on the current document.

  • Pick the bookmark text.

  • Edit the bookmark data.

  • Delete the bookmark.

Internet Explorer’s Favorites menu lets you do each of these for a single bookmark. While at the Yahoo! website, you can bookmark the site by choosing File Add To Favorites. This opens a dialog box where you can modify the information that will be stored. This dialog box lets you type in the text to appear on the menu item. You can also choose a category for the favorite (or create a new one). Ultimately these categories will just be submenus on the Favorites menu.

However, I find that this dialog box doesn’t offer enough configuration. For example, some sites have a link-sharing system, and when I click a link and end up at a site, instead of ending up at http://www.somedomain.com, I might instead end up at http://www.somedomain.com/ associateID=someone. If I bookmark the site, the extra associateID=someone ends up in the URL. If I want to remove the extra part and store just http://www.somedomain.com in the bookmark, I have to finish adding the bookmark and then go back in and edit it. That takes extra time, and remember, this chapter is all about wasting time. (Oh wait—you know what I mean!)

Therefore, in your Add Bookmark dialog box, if reasonable, please allow the user to specify the following:

  • Text for the menu item

  • Data (start with the current data and allow the user to customize it)

  • Category (and allow the user to create a new category)

To implement a bookmark system, you will probably want to include a command system that takes parameters. Then, when the user selects a bookmark, you would call a command, passing the information for the bookmark.

Since bookmarks usually live as menus, you will want to store the information for the bookmark in a Bookmark object separate from the text that appears for the bookmark. For example, the data behind a bookmark in Internet Explorer is a URL. If you’re writing a bookmark system for a code editor, then the data might be a named location within the code file. Or the data might be a filename.

You have several options for associating the data with a menu item. One possibility is that if your GUI library includes an extra data value with each menu item, you can store a reference or pointer to a Bookmark object. Or if you’re just storing ASCII data for the data, you can put that data right in the menu.

REAL WORLD SCENARIO: I’m Embarrassed to Admit That I Couldn’t Open the Door.

start example

This is a topic I almost left off, because so many other usability books have mentioned it. But wouldn’t you know, two days ago this actually happened to me. So this is a real-life experience that I’m about to share with you. But it’s embarrassing, so please don’t share this with my close friends and loved ones. (They laugh at me enough as it is.)

What happened is that I was on the road and I stopped in a hotel lobby to get a room for the night. It was pretty late (around 11:00 P.M. local time), and after a certain time they close the counter and then you have to use the little security window like you find at some banks and gas stations. But the lobby was still open, so I wandered inside.

After getting my room, I walked over to the door and I did the famous thing: I pushed the door and it didn’t open. I pushed again, and it didn’t open. I turned around and said, “Did you already lockand then out the corner of my eyes (you can see this coming) I saw that infamous word:

PULL

Yup. I did it. I really did. I said, “Oh!” and pulled the door.

Now I’m not one to always blame my problems on other people (okay, not really, but this time I think it’s justified). Usability experts (especially Donald Norman) have talked a great deal about the problems with doors. All too often, doors have a very strange bar on them that is flat and clearly looks like something you push.

Of course, this bar had nothing that instinctively told me that I needed to push it. Take an alien from Mars who has never seen the door, and it (they don’t have hes and shes there) would have no idea whether you push the door, pull it, or just smash right through it. But we do have certain idioms that help us become familiar with unfamiliar mechanisms. The door had a flat panel that clearly looked like something I should push. But the panel stuck out a bit and I could get my fingers behind it and pull.

That’s a bad design. If the door instead had a bar that fit my brain’s usual idea of a “pull” mechanism, then I would have been fine. Instead I embarrassed myself in front of the nice young woman behind the counter.

end example

A slightly more sophisticated approach is to store your bookmarks in a template container class that mimics the hierarchical structure of the menu. Such a data structure would be reuseable later on in other software. You would still want to link each menu item with an associated object in the container, however. (The real difference between this approach and just associating an object with each menu item is in whether you rely on the menu system to organize your data or your own container structure.) The problem with this approach is that if you give the user the ability to sort and organize the bookmarks, then you have to sort the container and the menus separately. To do that, you would probably sort the container and then completely rebuild the menu from scratch. Nevertheless, some people prefer this approach because it separates the GUI from the data. The choice is yours.

Tip

Take a look at Internet Explorer and see how you can also have the favorites appear in a pane to the left of the main browser window. This is a handy place for users to access the favorites and a feature you might consider copying in your software.

Finally, one very handy feature you might consider is the ability of your users to search the bookmarks. I’m one of those people who bookmarks several sites a day, meaning that as of today I have thousands of bookmarks crammed into my copy of Internet Explorer. One feature I would like to see is a search box where I can type, for example, PHP, and see all the bookmarks that have the word PHP in their title or description. Wouldn’t that be nice? You might consider a similar feature in your software.




Designing Highly Useable Software
Designing Highly Useable Software
ISBN: 0782143016
EAN: 2147483647
Year: 2003
Pages: 114

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net