MenuForm Fill-In Interfaces

Menu/Form Fill-In Interfaces

Menu/form fill-in interfaces, which are the main element of wizards, simplify the process of writing code, since users need only respond to inputs such as choosing the type of command desired and filling in the appropriate boxes to have the system create the code (Shneiderman, 1997, 1992).

Menu systems have the benefits of ease of interaction (especially when working with novice users), reduce learning time, require fewer keystrokes, and provide structure to the interaction and decision-making process. Disadvantages include the problems of slow speed for experienced users (and for the system in general), excessive use of screen space, and the problem of being cumbersome if many menus are used. Menu systems seem to be most useful in the preliminary stages of problem solving and interaction, when the user desires some structure rather than just being greeted with a forbidding prompt for commands (Shneiderman, 1997, 1992, 1987).

Another advantage of menu-based systems is that it eliminates the extensive memorization (and related training) necessary when using command languages. However, menu systems also need to be carefully designed so that the resulting system will be as easy to use and effective as possible (Shneiderman, 1997, 1992, 1987).

Menu and Form-Based Structures

There are a number of menu/form-based structures that exist:

• Single Menu Structure is the simplest form of menu structure. While there can be two or more choices available, as well as more than two screens, the basic organization is as a single menu. There are options within this category, including binary menu (yes/no choice), multiple item menus (one menu with more than two items), as well as extended menus (two or more screens with the same basic structure), pop-up/pull-down menus, multiple selection (choose more than one option at a time), and permanent (always on screen) menus (Shneiderman, 1997, 1992, 1987).

• Tree Menu Structures are used whenever a listing of items becomes so large and unwieldy that it is no longer easy to use. Therefore, menu systems are formed which use a tree structure, which involves the hierarchical classification or categorization of items (Brown, 1982; Clauer, 1972). This form of menu system is quite common and popular, and is used on various kinds of systems.

• Acyclic Menu Structures are more complicated than the tree structure, since they allow a certain menu in the "network" to be reached by more than one path. This type of menu "network" is more complex than the tree, and can result in greater disorientation and difficulty as a result of this. (Shneiderman, 1997, 1992, 1987).

• Cyclic Menu Structures allow the user to return to or repeat a previous or "higher up" menu, even though it has been used before. Instead of only moving in a straightforward manner, it also allows the user to "go back" to a previous, perhaps more general frame. This type of structure is even more complex than the acyclic, and can result in greater confusion on the part of the user (Shneiderman, 1987). For both this and the acyclic, the conclusion made by Mantei (1982) holds true: "the structure of the interface... causes disorientation if this structure is not obvious to the user" (Shneiderman, 1997, 1992, 1987).

• Depth vs. Breadth of Menu Structures is another important factor to consider, especially when menu systems involve more complex levels of nesting and hierarchy. There has been work done in this area, which attempts to explain the relationships between depth (total number of levels) versus breadth (number of items per level). Kiger (1984) looked at this problem and created several groupings of menu tree forms, with varying numbers of items and levels. The results showed that the menu with eight items and two levels seemed to produce the best results for accuracy and speed. On the other hand, the deep narrow menu tree had the worst results. Dray, Ogden and Vestewig (1981) compared one and two level menus, with the one level menu having greater breadth. It was found the one level menu was easier to learn. Miller (1981) also found that the speed of performance was best when there were four or eight items per menu screen, and eight seemed to result in the least errors. Doughty and Kelso (1984) reported that a menu tree having great depth, but very little breadth, required search times twice as long as those with more breadth but less depth. The results seem to suggest users are more efficient with menu systems that have breadth, however a great deal of depth seems to hinder performance. Results by Landauer and Nachbar (1985) also support this general conclusion.

• Form Fill-In Structure is another kind of menu design structure that has use in certain kinds of applications. It is especially useful in instances where a large number of keyboard entries are needed. The close resemblance to paper forms makes users comfortable with the format, and it also gives users the impression of being "in control." Detailed instructions are also not as necessary, as for other kinds of menu systems (Shneiderman, 1997, 1992, 1987). This type of interface system has been found to result in greater speed over command languages (Ogden & Boyle, 1982). There are a number of vital elements to effective form fill-in interfaces, including the use of meaningful titles, the inclusion of comprehensible instructions, maintaining a logical grouping and sequencing of fields. These ensure a visually appealing layout of the form, field labels, consistent technology and abbreviations, use of space, convenient cursor movement, easy error correction, error messages, optional fields, explanatory messages for fields, and providing some kind of signal for completion (Shneiderman, 1987). Research on form fill-in was conducted by Brown (1986), Pakin and Wray (1982), and Galitz (1980).

Wizards are now featured on many of the software we use daily, including components of the Microsoft Office suite, for example. They automate the process by leading the user through a series of input screens, after which the system will write the command or code for the user.

In addition to examining the role of interaction modes, it is also important to examine what markup languages are, and why they should be the subject of further study. Markup languages have become increasingly important in the computing community, because of their wide use in both Internet Web page design/development and electronic publishing. Simply put, a markup language consist of a set of tags, tokens, characters, or specialized commands which are placed in a body of text in order to provide information about the text or other data being processed (Coombs, Renear & Rose, 1987; Goldfarb, 1991).

Markups are sets of tags, tokens, characters, or specialized commands, which are placed into a body of text in order to provide information about the text or other data being processed. A markup could be as simple as a space or line feed, or a complex set of symbols for setting all the formatting details for a text document (Coombs et al., 1987; Goldfarb, 1981).

Markups enable one to "unlock" the data content of a document. In other words, a document is not just a stream of characters, but rather is a data structure that encompasses a great deal of content (Cronk, 1993).

The concept of a markup is simple - whenever you write something, you also "mark it up." Markups can be used to specify the boundaries between words, sentences, and paragraphs, and also indicate the typographical and structural features of a text, such as chapter headings, titles, and indented sections. Some forms of markup allow one to specify the various components of a specific document type, whether it is a book, article, or paper. There are several different kinds of markup, which are used.

One commonly used form of markup is punctuational markup. This basically involves adding punctuation to the text, such as commas, periods, question marks, and exclamation points (Coombs et al., 1987).

Presentational markup is another widely used form, which uses formatting commands to enhance the presentation of text. For instance, horizontal and vertical spacing, underlining, indenting, and page breaks are added directly into the text to make it more understandable and easy to read. Presentational markup clarifies presentation of the text (Coombs et al., 1987).

Procedural markup is another form of markup where commands placed in the text indicate how text should be formatted. Basically, it provides instructions to the text formatter, and might include commands to set line spacing, format text, justify (left, right, full) a paragraph, and the like. Usually a certain word processor or formatter has its own set of procedural markup commands (Coombs et al., 1987).

Probably the most important and significant type of markup is descriptive markup. This specifies what text element a unit of data is, and allows you to describe and classify it. A descriptive markup (command) language approach allows the creator of a document to define a number of "element types" or "data structures," which identifies a text portion as a member of a certain class. For instance, you can specify if a piece of text is a long quotation, table, paragraph, or a footnote (Blake, 1989; Coombs et al., 1987; MacLeod, 1990; Tuck, 1989)

The power of markup languages is becoming more apparent for the efficient formatting and processing of text, especially with the increased interest in electronic text manipulation, desktop publishing, the Internet, and the World Wide Web. Descriptive markup is of particular importance, because it allows a description of a document or text element that is independent of its final form and output. One important component of any markup language standard should be the inclusion of markups for survey question types. These descriptive markup functions would be very useful in providing support for survey applications and for extending the usefulness of markup languages.

A practical example of an existing markup language standard is SGML. SGML is an international standard for describing marked-up electronic text. SGML is less of a language in itself, but instead is a metalanguage, which is used to define a markup language. In order to create a formal specification for a SGML document, it is necessary to produce what is called a document type definition, or DTD. The elements of this need to be specified in a defined format, which includes elements such as angle brackets, element keywords, minimization rules, and content models. This standard for marking up text has been utilized by various publishers of information and is an important component of electronic publishing (Association of American Publishers, 1992; Wright, 1992; W3C Web page, 1998). A widely used instance (or application) of SGML is HTML (Hyper Text Markup Language), which is used to create hypertext-based documents (Web pages) on the Internet World Wide Web (Darnell, 1997; Mullen, 1998). Someone can easily create text, graphical, and forms-based "pages" which can then be placed on the Internet World Wide Web and presented to a global audience. The markup language developed here in this study can easily be added to the SGML and HTML standards, both for use on text processing systems and on the Internet (Hsu & Turoff, 1996).

Recent advances in markup languages include Dynamic HTML (DHTML), which includes as one important component cascading style sheets (CSS), as well as XML (eXtensible Markup Language). These represent some of the advanced HTML markup features that are available.

Dynamic HTML is an enhancement of HTML, in that the use of dynamic HTML can bring about such effects as dynamic styles, dynamic content, and dynamic positioning. Dynamic styles allow for changes in content without the need to re-load the entire page content back in each time. The use of dynamic content would allow for the graphics or text on a page to change, upon receipt of input from a keyboard or mouse. Graphics and text can also be moved around on a page using the dynamic positioning features of DHTML (Pardi & Schurman, 1998; Powers, 1998; St. Laurent, 1997). An important element of this is the use of cascading style sheets (CSS), which allows for the definition of style specifications which can improve document presentation and layout (Busch, 1998; Lie & Bos, 1997; Mace, Flohr, Dobson & Graham, 1998).

XML could be considered a less comprehensive version of SGML, in that it is more powerful than HTML, yet less complicated than full SGML, and is designed to be easier to use. It allows someone to define his/her own markup language and move beyond the fixed tags, which are found in a SGML application such as HTML. However, the use of XML requires the use of a special XML browser, which is different from the HTML-based browsers commonly used (Holzner, 1997; Leventhal & Lewis, 1998; Light & Bray, 1997; Mace, Flohr, Dobson & Graham, 1998; St. Laurent, 1997).

There are other new types of markup languages, especially for use with the Internet and World Wide Web, such as VRML (Virtual Reality Markup Language), which have been developed. They allow someone to develop three-dimensional virtual reality-oriented pages for the World Wide Web. There are a number of books that have been published on the use of markup languages (SGML, HTML, VRML), and this is a type of language, which has become widely accepted and used.

Using a descriptive markup language (Coombs et al., 1987) approach to creating surveys appears to be a viable alternative to the manual direct manipulation or WYSIWYG (what you see is what you get) approach which is currently the basis of most text editing systems commonly used for creating surveys.

The descriptive markup (command) language approach allows the creator of a survey to select from a number of "element types" or "data structures," which classify a text stream as a member of a certain type. A document that has been tagged with descriptive markup can be processed by different kinds of systems, and is independent of its final form and the specific system it is being processed on. Instead of specifying the intricacies of formatting and text presentation, it allows the focus to be entirely on the questions and structure of the questionnaire as a whole (Coombs et al., 1987).

One of the most important benefits of a descriptive markup approach to survey design is its ability to minimize cognitive demands. Rather than recalling, selecting, and remembering codes for the creation of entry and coding of procedural markup, there is only one step involved in descriptive markup after recognizing the element type - to use the appropriate markup command together with the text to be "marked up." This frees the survey creator from formatting concerns inherent in traditional direct manipulation or WYSIWYG methods.

The use of descriptive markup also has the benefits of better maintainability and portability. In terms of maintainability, in the case where the actual formatting or structure of a question (element) type needs to be modified, this can be done by changing the processing program or system, without affecting the markups or text. This allows the same data to be used across different applications and platforms, resulting in greater portability (Blake, 1989; Coombs et al., 1987; MacLeod, 1990; Tuck, 1989).

Going to a more general level, the benefits of markup could be related to the difference between command languages (markup) and direct manipulation (manual means). For a survey task, a markup language is best because users are familiar with the task, the number of element types is relatively small, dealing with survey questions as direct manipulation objects is slow and cumbersome, and the compactness of a command language makes it simpler to work with (Shneiderman, 1997, 1992, 1987).

Using a markup language allows a system to potentially aid the user by better expressing what the specific objectives or task is. The semantic approach inherent in the markup command language can be more effective than the direct manipulation approach, especially if incremental feedback, visual interpretation, or other learning aids are also used (Shneiderman, 1997, 1992, 1987).

While there have been studies conducted on command languages such as DOS or procedural programming languages, there have been few which have been on markup languages. The implications of this study, given the fact that many millions of people are getting onto the Internet and the World Wide Web, is that more effective help systems and learning aids can be developed which can help people to learn and work with markup languages such as HTML and SGML.

User background is another important factor, which was examined in this experiment. The previous programming background of the subjects is an important factor, which should be examined when it comes to evaluating interaction mode and performance/satisfaction. In general, experienced users tended to have a better "mental model" of a system or a language. There are a number of ways to obtain this kind of mental model-through usage, through analogy, and through training (Sein & Bostrom, 1989). A person can learn how a system is put together by using it; it is a function of the user interface, knowledge of other systems, and various individual traits. Analogies are also useful to help someone develop this kind of mental model, which can be heavily influenced by their use of similar systems or by previous experiences.

Payne (1988) found that one of the main differences between novices and experienced users was found in the kinds of mental models, which they have. Many novices having incorrect or ill-conceived models which lead to difficulty in actually conducting the task or writing the code. Since experienced users have much better mental models of programming and the use of markups, it is expected they would have better performance compared with novice users. In connection with this, knowledge and experience with the complexities of programming would tend to improve satisfaction for these same experienced subjects, as compared with novices.

This paper describes the background, results, and summary/conclusions for a research experiment which examines performance and satisfaction as it relates to the usage of a survey questionnaire markup language. The language used, which has specific markup tag types designed for the creation of questionnaire question types, was designed to be an enhancement to markup language standards such as HTML and SGML (Hsu & Turoff, 1996).