8.3.      Lunar Habitat Design Environments

This section will indicate how design environments built on top of Hermes can achieve goals that have long been set for Janus and Phidias but not previously achieved. In particular, it will argue that the combination of a powerful, integrated hypermedia substrate, a perspectives mechanism, and an end-user language facilitate the desired functionality.

Figure 8-3 shows a screen view of five open windows that are typical of the Hermes interface. This screen view is taken from a prototype Lunar Habitat Design Environment (Lhde) built on top of Hermes. From left to right, the windows are:

1. A control dialog for navigating hypermedia. It shows the selection of the discussion predicate for navigating the out-going links from an issue, “What are the design considerations for bunks?” Discussion is an expression in the Hermes end-user programming language, defined as an indented hierarchy of issues, subissues, answers, and arguments. The results of the query, discussion of the selected issue, is displayed in the next window.

2. The Design Rationale window shows the results of the query evaluated in the privacy perspective. The query was defined in the previous control dialog window by choosing a predicate relevant to the issue link type going out of the selected issue.

3. The Critique window displays the result of the critics analyzing the construction of a lunar habitat. The critics were evaluated as defined within the privacy perspective. The user initiated critiquing with a button (not shown) in the next window.

4. The Drawing window or construction area displays the current design. This window has buttons (not shown in the Figure) to change perspective, save the drawing in the current context, navigate links connected to the drawing (its rationale), and critique the construction.

5. The Context selection window (partially shown) allows the user to change to a new interpretive perspective in the context hierarchy. This affects contents of textual nodes, definitions of elements of the language used for expressing queries and critics, and contents of drawings.

Figure 8-3. A screen view of the Lhde interface.

In this interface to Lhde, one can see a 2-D graphical construction area similar to that of Janus and Phidias. Subsequently, a version of Phidias II has been built on top of the Hermes substrate by researchers in the College of Environmental Design’s CAD lab. It features a very general 3-D construction area, which can be viewed from any angle and distance. It allow a designer to move through the design space and view things at greater or less distance. The Lhde interface shown in Figure 8-3 has a palette of simple geometric shapes along the left edge of the drawing window. The Phidias II interface has palettes of chairs, tables, etc. specifically for lunar habitat designs. In both cases, the palettes are “hard-wired” and cannot be modified by end-users. However, this is not necessary when using the Hermes substrate. Instead, one could define an expression in the language to display a palette. This has not been done because Phidias II’s 3-D graphics system is not yet fully integrated with the Hermes substrate. The advantages of an integrated approach will be discussed below.

The Lhde interface shows a view of design rationale. This is dynamically displayed based on the results of the language expression, discussion of the issue selected (“What are the design considerations for bunks?”). Note that the system user did not have to worry about “programming” in the language. Everything was done by direct manipulation, and the language implemented things behind the scenes. The user selected an issue with the mouse in a previous Design Rationale window. The Navigation dialog appeared, with the “Navigate out-going links” option already chosen as the default and with the names of types of links coming out of the selected issue (namely, issue, i.e., subissues) listed in the Out-going Links box and the names of predicates “relevant” to those types (i.e., language expressions that begin by traversing links of those types) listed in the Predicates box. When the user selected discussion from the list of Predicates, the system automatically applied the discussion predicate to the previously selected node and evaluated the resulting language expression within the active perspective. The result is displayed in the new Design Rationale window. That window also has buttons so that the user can modify the display in a number of ways. The display can be replaced by selecting previously saved results. (A button for saving the current results is located at the bottom of the window.) Another button allows the user to select a different query to be evaluated; it displays a list of all defined queries. A third button allows the user to create a new query. This is the point where something like programming may enter, although the interface for the language encourages reuse and modification of previously defined expressions (see Chapter 10). Finally, a last button allows the user to select a different perspective, thereby changing the display.

The Phidias II interface provides an alternative display mode for design rationale and similar displays. Rather than showing an entire indented structure, it displays the top level of the outline form only (the unindented nodes). Every node that has hidden indented material is indicated with a small icon. Clicking on that icon displays the next level of indentation under that node. (This is similar to file directory displays in the Macintosh System 7 and Windows 3.1.) What is interesting here is that this mechanism is implemented with the Hermes language, not in a hard-wired, programmed-in way. That is, clicking on a node’s icon causes the evaluation of the expression, all associations of that node in the result list. The availability of the language made it easy to implement this interface feature, and ensures that the feature can be flexibly modified by simply modifying the definition of the language expression (which does not require recompilation) and can be done by an end-user.

The critics in Lhde are passive agents, similar to the triggers in Phidias. That is, the user must press a button to evaluate the critic rules. In Lhde, the critic rules are expressions in the language. (See Chapter 10 for the Lhde version of Janus’ kitchen critics and for an analysis of privacy critics for lunar habitats.) No additional mechanisms are necessary because the language is designed to traverse and analyze the hypermedia representations of the design situation. In Phidias II, the triggers for displaying design rationale on the selection and location of palette items is implemented using the Hermes language. For instance, the trigger for selection of chairs evaluates the expression, discussion of chair selection issue. As discussion is defined in the Lhde seed, this goes to the issue named chair selection issue in the issue base and displays all the related issues, answers, and arguments.

Of course, one could add additional components to a design environment built on Hermes. For instance, one could make critics fire automatically when a design unit they were defined for is moved, as in Janus. One could define specification linking mechanisms as in Kid, or formalization mechanisms as in X-Network. Even if these mechanisms were borrowed from other systems, the Hermes substrate would pay off. Critic rules would still be defined in the Hermes language, without having to be programmed in Lisp, and they could be associated with design units via general-purpose hypermedia links instead of special mechanisms. The specification linking would be greatly simplified in Lhde by defining domain distinctions as well as critic rules in the Hermes language, and then using the language to traverse the specification hypertext. Even the formalization mechanisms would be aided by using the Hermes language for formulating queries (as suggested in Chapter 7) and for providing a medium of formal (computer understandable) expression. The perspectives feature would also come in handy, allowing different versions of critics to be organized into perspectives and using these perspectives for making their critics more specific to the situation corresponding to that perspective (perhaps obviating the need for a separate specification mechanism).

The most important benefit of the Hermes substrate is the synergy possible with the hypermedia network, the perspectives organization, and the language expressivity. For instance, the Hermes substrate provides a useful basis for finally achieving the goals proposed as “future work” in the classic Janus paper (Fischer, McCall, Morch, 1989), as discussed in the following paragraphs:

(1) Within the argumentation system there is a pressing need for authoring to be integrated with browsing. (2) Allowing ad hoc authoring during browsing would enable the designer to annotate the issue base, record decisions on issues and generally personalize the argumentation. (3) This in turn would create the need for certain basic kinds of inference mechanisms. (4) For example, if the designer has rejected the answer “dining area” to the issue “What functional areas should the kitchen contain?” then the system should probably not display any issues, answers or arguments that presuppose or assume that the kitchen has a dining area.

(5) Construction and argumentation might usefully be connected in a number of additional ways. (6) Catalog examples could be used to illustrate argumentation, and argumentation could be used to help in selecting examples from the catalog (p.12; sentence numbering added).

(1) Integrating authoring with browsing. In the Lhde interface, authoring is integrated with browsing. At every step of hypermedia browsing, the navigation dialog in Figure 8-3 gives the user a choice of traversing out-going links, traversing in-coming (inverse) links, editing the current node or authoring or annotating the node. The editing option brings up an editor appropriate to the medium of the current node, with its content ready to be edited. (In cases of multiple contents, the contents are automatically placed in the editor consecutively.) The authoring option allows the user to create a new node and link it to the current node. Annotation is a typical application of this, where one links a text node to the current node with a link of type annotation. Adding the phrase, with their annotations, to a predicate will then include all the attached annotations in a given display. Of course, all authoring in Lhde takes place within the current perspective.

(2) Personalizing the argumentation. The authoring option in Lhde is also used for recording decisions in an issue base. Suppose you are browsing through a series of issues that correspond to the issues in Kid’s specification component. Then when you come to an answer that you wish to accept as a specification for your design, you can author a node that you attach to the answer with a resolution link. You define its content as the boolean value true. (This is easier to do in the Lhde interface than it sounds when described because the separation of nodes from their content is never apparent to the user, and the hypermedia linking is generally transparent.) In favoring the personalizing of the argumentation in the preceding quotation, the developers of Janus did not consider carefully the implications of having many users “personalizing” the same homogeneous issue base. It is one thing for Rittel to have advocated including the deliberations of half a dozen opposing positions in a single issue base; quite another to accumulate the exploratory thoughts of arbitrarily many users, over long periods of time, following diverse and unrelated interests. This may not be a problem for a single-user system; however, Lhde is intended as a repository for extensive exploration. The perspectives mechanism is an important tool that allows “personalization” to scale up in Lhde and to function in a collaborative setting.

(3) Inference mechanisms. In Hermes, the inference mechanism is not some add-on function, but the embedded language itself. While the language does not allow fully general inference across large sets of production rules, it does allow people to encode dependencies. Conditionals, for instance, are used in a number of ways in Lhde. The evaluation of any object in the database can be made conditional upon an arbitrary expression in the Hermes language that evaluates to true or false. Queries incorporating such conditional expressions can also be defined as the content of nodes. Another approach is used in Lhde to preface display expressions with conditional expressions, as illustrated in point (4).

(4) Adaptive argumentation. In Lhde one can build up a dining area conditional as follows:

if resolutions of answers of the functional areas issue that contain “dining area” are true.

As would be clear when building this expression in the language interface (shown in Chapter 10), the phrase, that contain “dining area”, is applied to the answers of the functional areas issue prior to checking if the resolutions of the answers that pass through that filtering condition have the boolean content, true. Once this conditional expression has been defined, it can be used in the variety of ways suggested in point (3). For instance, if the design rationale included the display expression, discussion of dining area issues, then that expression could be modified to be: if dining area conditional then discussion of dining area issues. This would display the issues, answers, and arguments concerning dining areas if and only if the dining area answer of the functional areas issue had been resolved in the positive.

(5) Connecting construction and argumentation. Because the Hermes hypermedia substrate integrates the construction graphics and the design rationale text, graphical examples from the catalog can be linked to entries in the issue base. Assume that a particular kitchen layout is linked to an issue about dining areas with an examples link. Then you can amend the display expression above to include dining area issues with their examples. Depending on whether the Lhde or Phidias II interface was being used, either the text and graphics would be inter-mixed in the outline indented form, or the graphic examples would be represented by an icon and clicking on that icon would display the graphic in situ or in another window.

(6) Connecting catalog and argumentation. In Lhde, catalogs are not fixed displays. They are defined by language expressions. These expressions can, of course, be modified with conditionals and other inferencing computations. Following are some sample catalog definitions illustrating a filtering of the content of the displayed catalog based on decisions in the argumentation (i.e., the issue base is treated as a specification component):

if dining area conditional then kitchens that contain dining areas

if safety is important then kitchens that are safe

if privacy is important then habitats that have parts that have privacy ratings

if privacy is important then privacy gradient catalog

The first of these evaluates the conditional that was defined earlier. If it is true, then kitchens are displayed if they contain subparts that are of node kind dining areas. The second makes use of an expression named safety is important, that checks the resolution of some issue related to safety. It then evaluates an expression that performs an analysis of kitchen layouts similar to the safety-related subset of Janus’ critics. The third again begins with a specification conditional. It then accesses all habitats in the database. For each habitat, it goes through its subparts to see if any of them have a link of type privacy rating. As soon as such a link is found, the habitat is added to the list of items to be displayed. The last expression takes the idea of the third one further, critiquing the separation of parts of a lunar habitat based on the privacy ratings attached to its parts (see Chapter 10 for a detailed analysis of this last expression).

These examples of the synergy possible with the Hermes substrate have emphasized the use of hypermedia linking made possible by an integrated substrate. That is, all the objects inherit common functionality, including the ability to be linked together. The role of the language as a tool for traversing the hypermedia has also been emphasized. Expressions in the language can be defined to relate information from different components of a design environment. The utility of the perspectives mechanism has not been stressed as much. However, it can play a powerful role in personalizing the information, in coordinating sets of specifications, and in promoting collaboration. That theme will be taken up in the next chapter.

Go to top of this page

Return to Gerry Stahl's Home Page

Send email to Gerry.Stahl@drexel.edu

This page last modified on January 05, 2004