On a different perspective, there exist some theoretical methods which can reduce the amount of information by focusing on the syntactic structure of the information. This simple and classic technique is the method used in Lisp printers (for example, see Steel [1990]). However, its drawback is that users must manually change each variable corresponding to their interests. A more elegant method is used in Furnas'[1986] generalized fisheye views. Using a priori importance of the hierarchical structure and logical distance from the focal point, generalized fisheye views made it possible to satisfy the following requirement.
Requirement 1.1. Details near a focal point and only important landmarks further away should be displayed.
For example, a normal screen editor displays a line currently focused on along with some consecutive lines before and after it. With fisheye views, users can see not only details around an editing line but also important lines such as while, for, or if statements. Furnas also conducted some user studies, and reported that these kinds of views which integrated details and contexts were useful in certain applications.
We agree that the aforementioned types of views can be helpful for users. From the cognitive viewpoint, however, it is not sufficient. The common problem in these previous methods, as we shall later describe in further detail, is the lack of ability to control the amount of information displayed when users change their focuses of attention. When users edit programs, the focused line changes continually. We believe that it is undesirable that the number of displayed lines changes drastically when users change their focal point. Thus, we must add another requirement for information display, and that is:
Requirement 1.2. The total amount of displayed information should be kept nearly constant regardless of whether users change their focus of interest.
This requirement is needed for physical space problems as well as for human cognition problems which we described earlier. Also, we recognize an addendum to the previous requirement as follows:
Requirement 1.3. This amount should be set flexibly.
The moderate amount to be displayed is different for each user. For the same user, this amount may change daily corresponding to the user's condition. Thus, the amount should be readily set.
This article describes a new method of information display, labeled fractal views, which is an application of fractal theory to information structures and which can satisfy these three requirements simultaneously. Although fractal views and Furnas' fisheye views are similar in nature, fractal views focus on solving a sibling overload problem which was not addressed in Furnas [1986]. By solving the sibling overload problem, the entire view size can be controlled.
In the following sections, the basic concept of fractal views will be described, as well as an extension from physical regular trees to logical general trees. Next, through an application example of our method to program displays, we will attempt to show how the necessary requirements for information display are satisfied. Finally, we will discuss the differences between fisheye views and our method, and discuss limitations of our method.
2. BASIC CONCEPT OF FRACTAL VIEWS
The fractal[Mandelbrot 1982] is an important concept because it makes it possible to discuss the complexity of an entity not only in quantitative terms, but in mathematical terms as well. In engineering fields, fractals are mostly associated with applications in image synthesis[Barnsley et al. 1988,Peitgen et al. 1992] or image processing[Kaneko 1987].Figure 1 represents triadic Koch curves which are frequently referenced as examples of fractal figures. Strictly speaking, these figures are just approximations called prefractals[Feder 1988] because real fractal figures are obtained in the infinite state. In other words, we must make infinite recursive calls to draw true fractal figures.
Figure 1: Generations of triadic Koch curve. By changing the scale, its abstraction level also changes.
This approximation mechanism is an abstraction of the complex object with a certain scale which is set by an observer. If a large scale is adopted, the degree of abstraction becomes high (see the upper figure in Figure 1). If a small scale is adopted, the degree of abstraction becomes low (see the lower figure in Figure 1). This approximation, by changing the scale, can also be seen when we process digital images and so on. We call this approximation mechanism fractal views.
The information structures used in computers, such as the directory structure of UNIX, (UNIX is a trademark of AT&T Bell Laboratories.) are generally represented as trees or networks. If we regard these logical structures as complex objects, and introduce a certain concept of scale, we can control the degree of abstraction as well as abstract these information structures. In this article, we limit our consideration to trees and formalize fractal views for information structures.
3. EXTENSION OF FRACTAL DIMENSIONS
We want logical trees to be viewable in controllable detail, analogous to different levels of prefractal display, and we need to do this regardless of heterogeneous branching. Figure 2 illustrates the fractal views for physical regular trees and those for logical general trees. In physical fractal trees, where each edge length is calculated by a fractal function described later, the tree can be observed in further detail by reducing the scale. In logical trees, after calculating the importance of each node using the fractal function, the size of the entire view can be controlled by changing the scale (threshold). This presupposes a fractal dimension for the trees. However, the fractal dimension described in Mandelbrot [1982] is for trees represented as figures, and not for logical trees. Thus, we extend the fractal dimensions in the following manner:- the similarity dimension for physical regular trees is briefly described;
- a log-log plot analysis is introduced in order to treat general trees;
- the condition that the general tree is said to be a fractal is shown, using the log-log plot analysis;
- this analysis is extended to logical trees.
Figure 2: Fractal views for physical regular trees and those for logical general trees. In physical trees, each edge length is controlled by a fractal function. In logical trees, the degree of importance of each node, which is represented by the radius of the node in this figure, is controlled by the fractal function. In both cases, by changing the scale, the different levels of abstracted views are obtained.
3.1 Similarity Dimension for Regular Trees
Figure 3 is a fractal binary tree drawn with a recursive algorithm. If the length of any branch is r times longer than that of the previous branch, the similarity dimension of this tree can be calculated to be:D = - log r 2 .
Figure 3: A fractal binary tree. If the length of each branch is r times longer than that of the previous branch, its fractal dimension is defined as - log r 2 .
In the same way, the similarity dimension of a tree which has N children at each node (we call it an N-branch tree) can be calculated to be:
D = - log r N .
3.2 Fractal Dimension by a Log-Log Plot
There are few objects in nature which are strictly self-similar. Mandelbrot proposed a more loose definition of the fractal as follows [Feder 1988, p. 11],A fractal is a shape made of parts similar to the whole in some way.
The figure of a coastline is one such example. To examine whether an object is a fractal or not, log-log plots are often used. In these plots, the x-axis indicates log delta, where delta is the scale, and the y-axis indicates log Lc(delta), where Lc(delta) is the length of the coast calculated with respect to delta. If the object is a fractal, the plot forms a line with negative slope, and the fractal dimension is calculated from that slope. Roughly speaking, it is the essence of a fractal object that a log-log plot of the size of the measurement unit versus the size of the object measured in such units forms a straight line with negative slope.
In Figure 3, if the length of the first branch is 1, the length delta of each branch under the nodes at depth n is delta = r^n . Thus, the total length L of all branches at this depth n is
L = delta * 2^n = (2r)^n .
If we eliminate n from the two expressions, by solving for L in terms of delta and r, we obtain
- L = (2r)^n
- = exp{ln (2r)^n}
- = exp{(ln delta / ln r) (ln 2 + ln r)}
- = exp{(ln delta (log r 2 + 1))}
- = delta^{1-D},
- = exp{ln (2r)^n}
T(delta) = L / delta = delta^{-D} .
If this relation is log-log plotted, the plotline is straight, and its slope is -D. That is, the total number of branches at a certain depth is a fractal, and its fractal dimension is D = - log r N. This value is the same as the similarity dimension we calculated previously.
3.3 Fractal Character of General Trees
Consider the grafted tree, which starts out as a fractal binary tree with a scale factor r2, and changes into a fractal trinary tree with a scale factor r3 at every node of a certain depth. The log-log plot of this grafted tree would be as shown in Figure 4.
Figure 4: Log-log plot of the grafted tree.
The plotline for the binary tree coincides with the plotline for the trinary tree at a certain point. The condition that two plotlines form a continuous line is that their slopes are equal. That is,
log r2 2 = log r3 3 .
To generalize the above concept, if the relation
log rx Nx = Constant (1)
exists between the number of branches Nx and a scale factor rx, at each node of a tree, the log-log plot forms a single line. Therefore, the tree satisfying expression (1) is said to be a fractal.
3.4 Extension to Logical Trees
The fractal dimension for an N-branch tree is calculated by focusing on the length of the branch. In the case of logical trees used in computers, however, it is impossible to calculate their fractal dimension because their branches are not composed of lengths. This problem can be solved by associating a conceptual value with each node. A conceptual value is given to each node, which we will call ``the fractal value'' for convenience, and this value changes by a scale factor. Figure 5 represents the fractal values of a logical trinary tree with scale factor r.
Figure 5: A logical trinary tree and its fractal values. The fractal value of a node is r times that of its parent.
With this conceptual extension, we can define the fractal dimension for the logical N branch tree whose fractal values are controlled by the scale factor r as
D = - log r N .
This definition can be extended to a logical general tree by using the same method described in Section 3.3.
To summarize, a logical general tree is said to be a fractal if there exists a relation
log rx Nx = Constant ,
between the number of branches Nx and the scale factor rx, at each node.
4. FORMALIZING FRACTAL VIEWS
In this section, we will formalize the definition of fractal views which associates a fractal characteristic to logical trees.First, the fractal value of the focus is set to 1. Next, after regarding the focus as a new root, we propagate the fractal values of other nodes with the following expressions by rerooting of the tree,
- Fv(focus) = 1
- Fv(child_of_x) = rx Fv(x) (2)
- rx = C Nx^{-1/D}
- Fv(child_of_x) = rx Fv(x) (2)
Figure 6 shows an example of the propagation when C = 1 and D = 1. For example, the fractal value of the focus (the root node in this example) is 1, and it has two branches. Thus the fractal values of its children are calculated as 1 * 2^{-1} = 1/2. Other fractal values are calculated in a similar manner. Thus, in Figure 6, if we desire to display nodes which have fractal values greater than or equal to a threshold 1/2, four nodes are displayed. If we change the threshold k to 1/6, all nodes are displayed. By changing the threshold, we can obtain different views.
Figure 6: An example of the propagation of fractal values.
Clearly, from Figure 6, the effective thresholds are 1, 1/2, and 1/6. There is no difference between 1/2 and 1/3. It would seem that there is no flexibility in setting the threshold. This is because the tree used in this example is a small one. As we will describe later, if we use a larger tree and consider each node as a root node, the number of effective thresholds increases. Second, in this example, if the number of branches is 1, the propagated value does not change (see the right branch in Figure 6. This problem is solved by setting C less than 1.
5. EVALUATION
In this section, we show the ability to control the amount of nodes through mathematical analysis. To simplify our discussion, C is always considered to be 1 in the following.In an N-branch tree, the total number of nodes, M, whose depth is smaller than or equal to n, is
M = {N^(n+1)-1}/(N-1).
On the other hand, the fractal value Fv of a node at depth n is
. Fv = r^n = N^{-n/D} ,
because r = N^{-1/D}. Thus, M is represented without n as
- M = {N Fv^{-D} - 1}/{N - 1} ,
- = {Fv^{-D} - 1/N}/{1 - 1/N} ,
when n disappeared.
This expression conveys that M nodes are displayed when the threshold k is set to Fv. As the branching factor, N, becomes large, the total number of nodes, M, moves asymptotically toward Fv^{-D}. Figure 7 represents the relation between N, M, and k. Note that the total number of nodes, M, begins to approach Fv^{-D} at relatively small branching factors, N, of 3 or 4. That is, the total number of nodes which have a value greater than or equal to the threshold is kept nearly constant regardless of the number of branches. Also, the effect of differing values of constant C, are as depicted in Figure 8. As it is clear from this graph, by choosing an adequate value, the total number of nodes, M, is constant even at small branching factors. Consequently, if we choose a certain threshold, we can display a nearly constant number of nodes whether the target hierarchy is a binary tree or a 100-branch tree.\footnote{However, if one sibling is displayed, it must display all of the siblings. Thus, it gives a much coarser granularity for the 100-branch tree than the binary tree.}
Figure 7: The relation between the number of branches at each node in regular trees and the number of nodes which have greater values than threshold k.
Figure 8: The relation between the number of branches at each node in regular trees and the number of nodes which have greater values than threshold k with different values of C.
In the case of general trees, it can be expected from Figure 7 and Figure 8 that the total number of displayed nodes are also kept nearly constant, since the total amount has no relation to the branching factor. We can support our claim that the amount of information in general trees should remain relatively constant by focusing on its fractal character. It is the fractal dimension that determines the characteristics of fractal objects, and objects with the same dimension have the same complexity. For example, it is assured that the Koch curve (Figure 1) with fractal dimension D = log 3 4 = 1.26.. and a coastline with the same dimension have the same characteristics. When each curve is covered with circles of the same diameter, the number of circles is the same. This is true even when we try using circles of a different diameter. This discussion is also valid for trees. In the case of physical trees whose edge length is determined by expression (1), the number of circles which cover the branch tips is statistically constant whether or not the tree is a regular tree. After the branches covered with circles are removed and the rest of the tree is measured in a larger scale, another statistically constant amount is obtained as well. This process is repeated to the first edge. Therefore, the total number of edges which have a greater length than a certain threshold in a general tree is also nearly constant as is in a regular tree. Since our method mapped the physical edge length to the importance of a node, the total number of nodes which have a greater value than a threshold (scale) in a general tree is also nearly constant as well as in a regular tree. This discussion will be supported by our experiments in the next section.
6. AN APPLICATION EXAMPLE
In this section, we show an application of fractal views. This is a program display application with comparison to Furnas' fisheye views. The resulting views were obtained by an interactive fractal view editor we developed.Here we will show how the requirements listed in Section 1 are satisfied. To clarify the capability of controlling the amount, we use a C program (see Appendix), which is listed in Furnas [1986], as the target program. This program can be regarded as a tree represented by its indentations. If the focused line is known, we can define the tree whose root node is the focused line, and fractal values of each line can be calculated with expression (2).
- Integration of detail and context:
For example, when the user's attention is on the 32nd line, different
views are obtained as shown in Figures 9 through
12 by changing the threshold.
In each figure, ``>>'' indicates the focused line.
In Figure 10, 26 lines are displayed.
Users can not only see the lines immediately preceding and following line 32
in detail, but can also recognize that they are focusing on a line
within switch, else, and while loops.
Figure 9: Fractal view focusing on the 32nd line (threshold=0.01).
Figure 10: Fractal view focusing on the 32nd line (threshold=0.02).
Figure 11: Fractal view focusing on the 32nd line (threshold=0.025).
Figure 12: Fractal view focusing on the 32nd line (threshold=0.05).
- Ability to control the amount:
Similarly, if the user's attention is on the 6th line, a different
set of views is obtained. Figure 13 represents the relation
between the threshold and the number of displayed lines when the user's
focus is on the 32nd line and when the user's focus is on the 6th line.
Note that each plot is almost on the same curve.
This implies that the total number of displayed lines is nearly
constant regardless of which line the user's focus is on. This fact also supports our
discussion form the previous section.
With Fisheye views, on the other hand, as we can easily recognize from the definitions of generalized fisheye views, the amount of displayed nodes is polynomial in the branching factor, and is exponential in the fisheye order. Thus, if the same threshold is adopted, i.e., viewing with the same order fisheye, the total amount of displayed information is absolutely different, depending on whether the target hierarchy is a binary tree or a 100-branch tree. Figure 14 represents the relation between the threshold and the number of displayed lines when users focus on the 32nd line and when users focus on the 6th line. As we can see from this graph, if users set their focus on the 6th line and view with the 3rd-order fisheye, users can see 19 lines. However, if they change their focus to the 32nd line, the number of displayed lines increases to 45 lines!
Figure 13: The relation between the threshold and the number of displayed lines with fractal views. All plots are almost on the same curve. Therefore, if we choose a certain threshold, the total amount is kept to be nearly constant whichever line users focus on.}
Figure 14: The relation between the threshold and the number of displayed lines with Furnas' fisheye views. Even though the same threshold is adopted, the total amount changes considerably when users change their focus.
- Flexibility of setting the threshold: As we can also recognize from Figure 13, effective thresholds increase when we focus on other lines. The space between plot markers is filled up with the markers for other lines. From a statistical point of view, we can change the number of displayed lines continuously, i.e., we can set the threshold flexibly. For example, setting the threshold to 0.1, the number of displayed lines can be kept to be about 10. If we want to display about 15 lines, we may set the threshold as 0.05. On the other hand, with fisheye views, we have only 6 thresholds. Thus, there is less flexibility in setting views.
Figure 15: An example screen image of multiscalable font mode. Each line is displayed with a different font size, which corresponds to the fractal value of each line.
Fractal views have been applied to other examples, such as visualization of huge hierarchies[Koike 1993a], Lisp Printers[Koike 1993b], and so on. Through these real implementations and experiments, the aforementioned features of fractal views, especially the ability to control the amount, have been verified.
7. DISCUSSION
Although the fractal view is similar to the fisheye view in many ways, it is not just a minor version of fisheye views. The high-level context property demonstrated here is not really related to fractal work. It is based on the rerooting of the tree at the focus. In this rerooting, nodes which are formally parents and children (one link away from the focus) are now equivalent children. Any method using monotonically decreasing functions has a weak high-level context property. Such methods, however, are weak because the views obtained by these methods cannot always display the path to the root. The main contribution of generalized fisheye views is the combination of such rerooting (distance function) and a priori importance of the target structure. In the case of trees, generalized fisheye views can emphasize their hierarchical structure and can always display the entire path from the focus to the root. On the other hand, since only a rerooting technique through fractal functions is used in our method, it cannot always display these paths. However, by using fractal dimensions as a measure of complexity, it can solve the sibling overload problem. It is the nodes with lots of children whose offspring will be the first to disappear. As to which view is most useful is a user-dependent problem. If it is important to display the entire path to the root, one should use fisheye views. If it is important to control the amount of displayed information, one should use fractal views.It may be interesting to combine our fractal function and the API function in fisheye views. It may also be worthwhile to apply our fractal function to network structures. Sarkar and Brown [1992] applied the fisheye view to network structures. In the same way, our fractal function can also be applied to networks by regarding them as a kind of DOI function. In this case, however, the value propagated to each node is no longer a fractal. Therefore, there is no assurance that this method can allow a nearly constant control of displayed information. An additional function which calculates the fractal dimension for the network would be necessary.
As for computational efficiency, since the values assigned fall monotonically away from the focus, the calculation time necessary to determine which nodes to show is proportional to the view size, not the size of the whole structure.
Even with our method, we cannot display an exact and constant amount of information. In such case, we may select nodes by, for example, the breadth-first search. Consider the tree whose root node has two children. One child is also a root node of a 100-branch tree, and another is a root node of a binary tree. If we want to display 10 nodes, with breadth-first search, we can display 7 children of the former child, or we can display 5 children of the former and 2 children of the latter child. However, in this case, nodes which have the same parents have different importance. With our method, we cannot always display exactly 10 nodes, and instead we can only display nearly 10 nodes (the root, 2 children, and 6 nodes under the latter child).
In the software applications we described in Section 1, however, it does not seem to be necessary to display an exact and constant amount. It is more important to give the same relevance to the sibling nodes. In the previous example of program display, we adopted a display/hide strategy. If we do not want to hide any lines and want to display unimportant lines in a grey scale proportionate to their importance, we can use the fractal values of nodes.
The high-level context views will cause some problems which should be resolved. For example, controlling the relation between the context of the old and the new views is very important. In order not to disturb the users' cognition, it would be helpful to change views continuously as demonstrated in Mackinlay et al. [1991] and Robertson et al. [1991]. It is also important to inform users of what is missing in such views. The map of the global structure of the information which is used in the function call graphs[Teitelman and Masinter 1984] may minimize such problems.
We have not, as of yet, conducted formal user studies. Furnas [1986] conducted experiments and reported that his fisheye views were useful in some applications. Since our method gave users similar views to fisheye views, we think the fractal view is also useful in such applications. The fractal view, moreover, can control the entire view size.
8. CONCLUSIONS
This article proposed a new method for information display named {\it fractal views}, which is an application of fractal theory to logical information structures. Fractals have been used to measure the complexity of physical objects or to synthesize physical images. By regarding the information structures used in computers as complex objects and introducing the concept of a fractal, we have succeeded in minimizing the sibling overload problem which was not addressed in Furnas' fisheye. The main features of our method are:
- the total amount of displayed objects is nearly constant when users change their focuses of attention;
- this amount can be set flexibly.
Fractal views may also be applied to other areas, such as hypertext systems, structured editors, graph drawings[Sarkar and Brown 1992], information visualization, and computer graphics applications. When fractal views are applied to hyperyext systems, it is possible to close automatically the windows far from the focus and to keep the number of windows nearly constant. In interactive computer graphics applications such as virtual reality systems, the system's response time can be kept nearly constant by controlling the number of graphic objects.
Since fractal views only consider the syntactic structure of information, there is no assurance that the display obtained by fractal views display what the users really want to see. However, we think that the syntactic approach without thinking of semantics may be useful. As was described earlier, information display control is a main concern in designing user interfaces. Our method, used independently or combined with other approaches such as large-screen approaches, may minimize these problems.
APPENDIX
Target Program
ACKNOWLEDGMENTS
The author would like to express his deepest gratitude toward George W. Furnas of Bellcore for his many substantive comments and discussions to improve this article, Steven Feiner of Columbia University for his helpful advice, Takemochi Ishii of Keio University for his many useful suggestions, and all the referees for their useful comments.Reference
-
Barnsley, M. F., Jacquin, A., Malassenet, F., Reuter,
L., and Sloan, A. D. 1988.
Harnessing chaos for image synthesis.
Comput. Graph. 22, 4, 131-140.
-
Bolt, R. A. 1984.
The Human Interface.
Lifetime Learning Publications, Belmont, Calif.
-
Card, S. K. and Henderson, D. A., Jr. 1987.
A multiple, virtual-workspace interface to support user task
switching.
In CHI+GI 1987. ACM, New York.
-
Card, S. K., Robertson, G. G., and Mackinlay, J. D.
1991.
The information visualizer, an information workspace.
In Proceedings of the ACM Conference on Human Factors in
Computing Systems (CHI'91). ACM, New York, 181-188.
-
Fairchild, K. M., Poltrock, S. E., and Furnas, G. W.
1988.
SemNet: Three-dimensional graphic representation of large
knowledge bases.
In Cognitive Science And Its
Applications For Human-Computer Interaction, R. Guindon, Ed.
Lawrence
Erlbaum Associates, Hillsdale, N.J., 201-233.
-
Feder, J. 1988.
FRACTALS.
Plenum, New York.
-
Feiner, S. and Beshers, C. 1990.
Worlds within worlds: metaphors for exploring n-dimensional virtual
worlds.
In Proceedings of the ACM SIGGRAPH Symposium on User Interface
Software and Technology (UIST'90). ACM, New York, 76-83.
-
Fisher, S. S., McGreevy, M., Humphries, J., and
Robinett, W. 1986.
Virtual environment display system.
In Proceedings of ACM 1986 Workshop on Interactive 3D Graphics.
ACM, New York.
-
Foley, J. D. 1987.
Interfaces for advanced computing.
Sci. Am. 257, 4, 126-135.
-
Furnas, G. W. 1986.
Generalized fisheye views.
In Proceedings of the ACM Conference on Human Factors in
Computing Systems (CHI'86). ACM, New York, 16-23.
-
Halasz, F. G., Morgan, T. P., and Trigg, R. H. 1987.
Notecards in a nutshell.
In CHI+GI 1987, ACM. New York, 45-52.
-
Kaneko, H. 1987.
Fractal feature and texture analysis.
Trans. IEICE 70, 5.
In Japanese.
-
Koike, H. 1993a.
The role of another spatial dimension in software visualization.
ACM Trans. Inf. Syst. 11, 3 (July), 266-286.
-
Koike, H. 1993b.
Implementation of a lisp printer using fractal views.
In Proceedings of 10th Conference of Japan Society for Software
Science and Technology, 101-104.
In Japanese.
-
Koike, H. 1992.
An application of three-dimensional visualization to object-oriented
programming.
In Advanced Visual Interfaces (Proceedings of the
International Workshop AVI'92), T. Catarci, M. F. Costabile, and
S. Levialdi, Eds. World Scientific, Singapore, 180-192.
-
Koike, H. and Yoshihara, H. 1993.
Fractal approaches for visualizing huge hierarchies.
In Proceedings of 1993 IEEE/CS Symposium on Visual Languages
(VL'93). IEEE Computer Society Press, Los Alamitos, Calif., 55-60.
-
Mackinlay, J. D., Robertson, G. G., and Card, S. K.
1991.
The perspective wall: Detail and context smoothly integrated.
In Proceedings of the ACM Conference on Human Factors in
Computing Systems (CHI'91). ACM, New York, 173-179.
-
Mandelbrot, B. B. 1982.
The Fractal Geometry of Nature.
W.H.Freeman and Company, New York.
-
Peitgen, H.-O., Jurgens, H., and Saupe, D. 1992.
Chaos and Fractals: New Frontiers of Sciences.
Springer-Verlag, New York.
-
Robertson, G. G., Mackinlay, J. D., and Card, S. K.
1991.
Cone Trees: Animated 3D visualizations of hierarchical
information.
In Proceedings of the ACM Conference on Human Factors in
Computing Systems (CHI'91). ACM, New York, 189-194.
-
Sarkar, M. and Brown, M. H. 1992.
Graphical fisheye views of graphs.
In Proceedings of the ACM Conference on Human Factors in
Computing Systems (CHI'92). ACM, New York, 83-91.
-
Shu, N. C. 1988.
Visual Programming.
Van Nostrand Reinhold, New York.
-
Steele, G. L., Jr. 1990.
Common Lisp the Language, 2nd ed.
Digital Press, Bedford, Mass.
-
Teitelman, W. and Masinter, L. 1984.
The Interlisp programming environment.
In Interactive Programming Environments. McGraw-Hill, New York.
Received July 1992; revised August 1994; accepted September 1994