My favorites ▼ | English ▼ | Sign in

Google Desktop APIs (Labs)

Improving User Experience

This article was written and submitted by an external developer. The Google Desktop Team thanks Teodor Filimon for his time and expertise.


Teodor "Teo" Filimon, Gadget Developer
November 2008
"Go forward" - Christopher Reeve

Introduction

The essence of writing a gadget revolves around the goal of making users' lives better somehow. There are many creative ways of doing this, but a few common standards can be used to improve the user experience. These standards can range from subtle tricks to powerful techniques.

Programming a gadget and planning for updates

The most important factors in ensuring a good life for your gadgets are retaining a fair number of users and presenting a good general impression. To do this, we must adapt to the environments where the gadget is run, strive for maximum performance, and plan for future updates.

For example, your gadget may deal with the online world by discovering a user's friends with the Google Talk API. Or it may fetch content from the web through the XMLHttpRequest object. In either case, imposing a proper online behaviour makes the coding easier and the communication processes more efficient. When dealing with offline-specific issues, such as image handling, information storing, etc., a proper offline behaviour should be applied as well.

Coding can also be optimized through techniques such as object-oriented programming or parameterization of constants or settings. Also, don't forget internationalization: separating the strings into a unique file for easier translation and reuse. These techniques also allow you to think in terms of high-level structures and isolate parts from changes, thus making implementation of improvements easier.

Attractive and intuitive user interfaces

Each aspect of the gadget has its own established importance, but it's usually the interface that decides if users keep your gadget or uninstall it. You don't need to be an artist to pull it off - a 'good' interface goes beyond looks, and here are some issues you need to take into consideration:

  • Ease of use. Making an interface intuitive isn't hard at all. It may not always be observed by the user, but it's definitely going to be felt or sensed during use. For example, let's think about an <edit> box being used as a search box. To most people, the natural behaviour is typing in a query and then hitting the Return key. You'd be surprised how many times such an important thing is left out.
  • Versatility refers to the ability of the interface to change depending on the situations the gadget confronts. Think about the online/offline discussion we had earlier or about the docked/undocked status of the gadget. Docked means it's inside the sidebar, so you have to be very careful about the available space (especially in the vertical dimension). :-) Undocked means the gadget is basically floating on the desktop and shouldn't have any limits to its position and size.

The impact new features have on the interface should be taken into consideration as well. You should aim for a good balance between UI elements in the main view, menu items, and settings in the options dialog. You should also be consistent with the type of features each of these areas host, so everything looks organized to the user.

User feedback

Aside from usage stats, user feedback is the only direct confirmation of your gadget's success. Not only that, but it's the best source of suggestions and bug reports. There are many ways of gathering feedback, and they range from a simple email address or a web page URL in the About dialog to an actual form on your site.

Taking things a bit further, you can identify which issues occur more frequently and then include corresponding tips and tricks as a P.S. in your answers. For example, I've seen that my users often ask for features in my gadgets or want to develop a gadget themselves. So I include tips about spotting gadget update notifications and links to the developer community. Implementation methods may vary, but the goal is that the user gets support through relevant and easy-to-understand answers, as well as you getting important reports and suggestions.

Gadget update system

As stated above, user feedback often translates into improvements being made to your gadget. There are simple and complex ways you can inform your users of updates:

  • changing the <version> tag: the <version> tag can be found in the gadget.gmanifest file. It is used by Google Desktop to check whether the online, hosted version of the gadget is newer than the installed version. Users can see these updates in the 'Updates' tab from the 'Add gadgets' dialog.
  • roll your own: The gadget can automatically (or manually) check for updates, and this can be implemented using the XMLHttpRequest object. The process can be bandwidth efficient, and here's one approach:
    • Step 1: fetch version from an URL.
    • Step 2: if there is a newer version available, fetch information about the latest feature from another URL.
    • Step 3: if the user agrees, proceed with the update (i.e. direct the user to the download page).
    Here is an article that teaches you how to implement an update system.

Embedding a calendar with a planned update timeline on the gadget web page can also be a good idea.

Attracting users

A gadget can be very good, but it will be useless if users can't find it. What you need to keep in mind, are the ways a user can come across your gadget:

  • searching: this can happen either in the gadget gallery or in the 'Add gadgets' dialog. To make sure your gadget is findable, you should give it a short, relevant name (most of the time people don't use complex terms in their queries). Make sure you also have a relevant description that states everything your gadget can do.
  • browsing: in this case, you need to pay attention to your screenshots. While the large one (300x225) can simply show your gadget as is, the key can be the small thumbnail. The trick is to convey a general idea about the gadget in the limited space. Remember that it will be competing against other gadgets. :-) Here is a tip about screenshots from the Google Desktop APIs blog.

Conclusion

Understanding these topics can seem a little complicated, but once you get the hang of it you'll see that they are just natural design and implementation decisions. Their purpose is to ultimately create the best possible gadget for the user.

Resources

Author bio

Teodor Filimon

I'm a natural born programmer. My first contact with a techno-gadget was Star Trek (remember those cool sensors?). I used to fill up a whole room with drawings of them when I was only 3 years old. Generally, I find a lot of inspiration for intuitive interfaces in things with "star" in their names (like Star Wars, Stargate,... :-) . I like the border between interface and functionality the essence of a program, I think. Anyway, I'm a software engineering student now, and you can learn more about me and what I'm thinking and doing at my website or blog. My best gadgets are Web TV and Radio and DigiWatch.


Creative Commons License
This work is licensed under a Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License.