Since the introduction of the World Wide Web about twelve years ago, the services that web sites provide to users have continuously become more sophisticated: From presenting static information, sites have evolved to offer simple one-step interactions (e.g. search engines), then multi-step transactions (e.g. shopping carts), and now complex applications (e.g. e-mail readers, customer support systems, portal systems), where the user interface (UI) consists of web pages presented in a browser. Compared to traditional window-based UIs, hypertext-based UIs require only modest client capabilities, making them suitable for a wide variety of client platforms, especially thin clients such as mobile devices with their strict energy, memory, input and output limitations. Furthermore, the simple information elements and interaction techniques of hypertext-based UIs can easily be ported to various presentation channels, meeting the increasing demand of users to be able to work with applications very flexibly - ideally, any service should be available on any device, anywhere, anytime. With reasonable effort, this requirement can virtually only be fulfilled by employing the thin client principle, where the application logic is implemented presentation channel-independently on a central server, while the UI is rendered individually on various client devices.

However, when developing applications with hypertext-based UIs, software engineers need to be aware that their implementation differs in some important characteristics from applications with window-based UIs [RF96]: Firstly, different presentation channels have different input and output capabilities (e.g. regarding screen size), possibly restricting the amount of information users can work with at a time. Consequently, presentation channel-independent applications must not only implement different UIs, but also be able to handle different interaction patterns. Secondly, hypertext-based UIs present information on pages instead of in windows. Consequently, interactions that would be performed without involving the application logic in a window-based UI (e.g. closing a window) require the generation of a new page in a page-based UI and thus involve the application logic for every interaction step. Thirdly, hypertext-based UIs employ a request-response mechanism to pull data from the server. Since the application logic cannot push data to the client, it can only react passively to user actions (e.g. clicking on a link) instead of actively initiating dialog steps (e.g. opening a new window). Finally, HTTP is stateless: The protocol only transports data, but does not maintain any information on the state of the dialog system. Consequently, the application itself has to manage the dialog state for each user session, which requires complicated logic for more complex dialog structures.

Regarding the impact of these characteristics on the user experience, one of the most notable effects is the limitation to simple dialog structures in many hypertext-based applications today: Linear and branched dialog sequences can be easily implemented and are therefore commonplace, but already simple nested structures (e.g. an authorization form inserted at the beginning of a sensitive transaction, leading the user to different pages depending on his credentials, or returning him to where he came from in case of an invalid login) require a lot of dialog control logic, and no application that the author is aware of is capable of nesting arbitrary dialogs on multiple levels.

Since users have a long-established conceptual model of nested dialogs from window-based applications, they will likely transfer that model to hypertext-based applications. However, because of insufficient dialog control logic, many applications still violate users' expectations today when they send them to other pages than they intended to reach (in some web applications, for example, login forms return users to the homepage after a successful login instead of sending them to the area that required authorization, requiring the user to navigate back to the desired area). This violation of the dialog principles of controllability and conformity with user expectations imposes a high cognitive and memory load on the user.

Based on the hypothesis that nested dialogs can improve the usability of hypertext UIs, this thesis therefore introduces a notation for specifying complex, nested dialog flows, and presents a framework to control them.

2. The Dialog Control Framework >