Understanding Task-orientation

Many developers today don’t understand the concept of task-orientation because they haven’t had to consider it before. Working with menus and toolbars has become the standard over the years and some developers see it as the only way to get something done. However, with task-orientation, you really don’t consider the old paradigm. What you do instead is consider the steps that the user must perform to accomplish the task and design the interface with this need in mind. Let’s begin by looking at a typical Word application as a starting point.

As an example of task-orientation, consider creating a letter. When you create a letter, you normally perform a sequence of steps such as adding a return address, the recipients address, the letter body, and a signature. Your letter might also include a list of carbon copies and could require a sign off by your boss. To perform this task in Word, you’d normally have open the correct template, select a style, type the heading, select another style, type the recipient information, and so on. There’s a lot of room for error in this sequence because you’re relying on the user to know how to use Word features. Figure 1 shows an example of a Ribbon interface for the same need.

Figure 1: Task-oriented applications help the user create documents without worrying about the application.

In this example, the user begins by selecting the kind of document to write. After selecting a document, the user chooses a recipient for the document, the current date, the sender information, a greeting, and a signature. Optionally, the user can also choose some other elements, such as a routing slip. The user moves from left to right, chooses some essential information that relates to the document, and never thinks about how to work with Word. This example demonstrates the goal for task-orientation. The user shouldn’t have to think about the application, ever. Only the document is important.

I tried a full-fledged version of this example at a company and the results were amazing. The task-oriented application reduced support calls significantly, documents produced with it contained few (if any) errors, and all of the output followed company policies precisely. The best thing is that the company achieved all of these improvements and saw an increase in user productivity as well. If you want to see the full implementation of this example, you can find it in my book, RibbonX for Dummies (http://www.amazon.com/exec/obidos/ASIN/047016994X/datacservip0f-20/) (Wiley, 2007). My book includes a wealth of VBA and VSTO examples that demonstrate how to make best use of the Ribbon in a number of environments. You’ll also see examples for each of the Office applications that currently support the Ribbon.

The main issue with the Ribbon today is that it focuses on task-orientation. A power user is actually going to experience a productivity reduction because the Ribbon tends to enforce a particular way of accomplishing a given task and power users tend to work in a freeform manner. Microsoft provides a number of methods for extending the Ribbon to make it less draconian, but in the end, this interface truly is best for accomplishing specific tasks. Of course, there are many applications that require this approach. Using the Ribbon interface in your application could reduce or eliminate the need for wizards and ensure that users don’t get frustrated using the product. The Ribbon interface could make performing complex tasks, such machine maintenance, considerably easier and well within the realm of things that less skilled users can do.

Understanding What Microsoft and Others Provide

Microsoft doesn’t actually provide you with any programming tools to create your own Ribbon application beyond what you can access in Office 2007. The lack of programming tools is one of the reasons you should probably work with Office for a while to get the feel of the Ribbon in an existing product. The main resources that Microsoft provides are an extremely detailed Ribbon specification and a royalty free license to produce your own Ribbon applications on any platform (yes, Microsoft would even let you put the Ribbon on the Mac or Linux).

In addition to these main resources, Microsoft provides a number of developer aids in the form of online content. The sources of online content include:

• Questions Regarding Implementation Requirements: officeui@microsoft.com
• Jensen Harris: An Office User Interface Blog: http://blogs.msdn.com/jensenh/
• 2007 Microsoft Office System UI Extensibility: http://msdn2.microsoft.com/en-us/office/aa905530.aspx
• Office Developer Center: http://msdn2.microsoft.com/en-us/office/default.aspx

These online sources provide you with considerable information about how Microsoft is using the Ribbon, but don’t say too much about how others are using it. The testimonials at http://msdn2.microsoft.com/en-us/office/aa973809.aspx give you a few ideas of how others are working with the Ribbon, but don’t really examine the results. It’s only after you start looking on other Web sites that you begin to understand that other people really are creating their own Ribbon products. Here are a few places you can go to for Ribbon-based tools right now:

• divelements: http://www.divelements.com/net/
• 90 Degree Software: http://www.90degreesoftware.com/
• Mindjet: http://www.mindjet.com/us/
• Syncfusion: http://www.syncfusion.com/

After you spend a little time looking at the applications that are already out there, you begin to understand that the Ribbon really is a great interface for users who perform the same tasks every day (which describes the majority of users out there). Don’t get the idea that Microsoft partners and large companies somehow have a corner on the Ribbon market either. You can find a wealth of resources in my book, but a few notable additions have come out since I wrote it. For example, check out Ribbon Creator (http://www.freedownloadscenter.com/Programming/Editors/IDBE_Ribbon_Creator.html), an interesting product for designing your Ribbon quickly. You can also see show a Mono developer brought the Ribbon interface to Linux at http://arstechnica.com/journals/linux.ars/2007/08/30/mono-developer-brings-the-ribbon-interface-to-linux. The point is there are resources out there for just about any Ribbon development need today; just grab what you need!