The Importance of Revision in Computational Models of Design

A new, more cognitively plausible, model of design, the Generate-Revise* model, is proposed. This model focuses on the importance of continuous revision in design work. Preliminary work on an implementation is also described. Design as an activity Design is a complex activity with connections to many cognitive mechanisms. It is a dynamic and challenging process. Design can be seen as a “purposeful, constrained, decision making, exploration and learning activity” (Gero, 1994). This activity is purposeful in the sense that the designer has a goal to achieve, whether this goal is to designing a building, a spoon or a book cover. It is constrained because the chosen domain provides functional, structural and behavioural restrictions that must be obeyed. Learning can be an aspect of revision, as will be explained later. The designer must also explore the possible design space and be open to possible transformations of this space. At the same time, many of the constraints and affordances of this design space are based on the designers perception. During the development of the design, these perceptions change and with them does the design space. The designer is therefore exploring a design space that changes because of this exploration. While it is outside the scope of this article to deal with representational issues in detail it is nevertheless important to recognise that this requires a great deal of flexibility in the underlying representation of domain information. Context-sensitive representations Flexible, context-dependent representations have been developed by, among others, Kokinov (1994b), Mitchell (1993), McGraw (1995) and Rehling (2000). The common theme among these is a hybrid approach somewhere between symbolic and connectionist systems. These systems are flexible, not only with respect to the context, but also in external appearance. They can be viewed as belonging to several different paradigms all at once. From one perspective they can be seen as ordinary semantic networks (like the slipnets used by Mitchell (1993), McGraw (1995) and Rehling (2000)) where nodes are connected according to their semantic proximity. This sematic perspective focuses on the systems function as a knowledge base. They can also be seen as traditional connectionist systems, using spreading activation to select relevant parts of the symbolic parts or even to determine the speed of execution as in the DUAL system (Petrov and Kokinov, 1999). The background state of activation is determined by prior executions as well as perceptual activations, thereby gaining a context-dependent activation pattern. It is important to note that flexible, context-sensitive memory representations easily becomes inefficient. This makes it difficult to generalise these models. Care should therefore be taken to ensure efficiency. Further discussion about this is given by Kokinov (1994a). The importance of revision So far, the dominant model of creative design has been the so called Generator-Test model. This model was proposed by Simon (1969) as a model of problem-solving but Dennett (1978) and others have used it as a model for creativity and design as well. Basically, it consists of two modules, one generator of ideas and one module selecting the best from the output of the first module. Lots of variations of this idea have been created over the years but the fundamental dichotomy of the model is always apparent. A major drawback of the Generator-Test model is that it basically is a one-pass system. That is, first the generator does its thing, and only then does the selection take place. There is no feedback to the generator and the generator part has normally no knowledge about the criteria used by the selector (or even that a selector exists). Even in the cases where some feedback does exist, it is usually only to enable the selector to restart the generator in case it didn’t find any acceptable candidates in the current output. Typically, information about the reason for this failure is not given to the generator. That model is akin to the case of an artist who paints several canvases while wearing a blindfold and then selecting the best from them (or even letting someone else choose), which would be a very unusual style. An ongoing process of review during the work is central and this process influences the work to be done. There is, in essence, an continuous process of revision. This is most obvious in the case of drawers, sketching a new drawing. New strokes are added to old to move lines, soften curves, sharpen corners, etc., all with the purpose of improving on the first attempt. When satisfied, the drawer then fixates the end result with bolder lines, perhaps even using ink. Writers are another group of individuals where this revision process is particularly evident. Manuscripts are rewritten, several times, in varying sizes, all the way from chapters down to fiddling with individual sentences. The end result is much better that the first rough draft. Revision is inherent in all creative work, but this has rarely been included in artificial models of design and creativity. In response to this, I propose another model of design, called the Generate-Revise* model (the star comes from its use in computer science to denote repetition). This model is not new, neither is it my own (though the name is), but it has received very little attention in the field of artificial design. This is amazing as revision is so prevalent in every kind of creative work. Two variants of the model can be conceived. In the first variant some subsystem creates its output, much like in the Generator-Test model, and this output is then judged by some other component. Again, so far it is identical to the Generator-Test model. The difference is that the judgement is then passed back to the generator to be used to revise the output just created. The new version is then judged again and so on, continuing until the output is of sufficient standard to be considered the output of the whole system. A partial example of this model is Letter Spirit (McGraw, 1995; Rehling, 2000), where the Drafter is the generator and the judging is carried out by the Adjudicator. However, no direct feedback is given to the Drafter, instead the top-level program decides whether or not to replace the old (if any) version of the current letter with the new one based on the Adjudicator’s judgements. The second variant, is a system where the feedback is given while the generator is working. That is, the generator is no longer working “blindly” as even unfinished designs are evaluated by whatever evaluation-module the system has and that evaluation can immediately influence the ongoing work. Such a system would very much be like a sketcher, who has immediate access to visual feedback about the emerging drawing created. It is important to note that both variant must include some form of learning capacity even if it is in the most rudimentary form. At the very least it must avoid making the same mistake twice. While there are many flavours of learning algorithms and this is not the place to review them, it would be an interesting prospect if the system could get a long term benefit from the revision process. Typographical design as an example As an example of this model, a prototype implementation is under development. This implementation works in the area of typeface design. The basic idea of this implementation is the same as in the Letter Spirit project (McGraw, 1995; Rehling, 2000), to develop a computer program that, given a small set of seed letters, can design new letters in the same style as the seeds and to be a demonstration of how creative design might work. An overview of typographical design While the shapes of letters differ wildly between typefaces, some common structural parts can be identified. Some examples of parts are vertical stems (like the backbone of an upper case ’B’), horizontal arms or crossbars and diagonal strokes. Enclosed bowls are also common (the letter ’O’ consists of a single bowl). In some typefaces, parts can have their endpoints decorated by serifs (like the letters you are now reading). The basic decomposition of letters into parts are usually the same between typefaces but the realisation of these parts can vary. These terms are in the language of typographers which is important because a human typographer working on a new typeface does not think in terms of bezier segments (the usual representation for curves in digital typefaces) but in terms of stems, arms, serifs and so on and of attributes of these parts, such as widths, heights, and so forth. Therefore, this model should do this as well. Thus it is important to decompose and organise the shape of a glyph (which is normally given as a contour) into parts so that relevant features can be identified. The implementation described here contains models of characters in terms of these abstract parts (compare the use of roles in McGraw et al. (1994)). The use of typographical parts also allows the system to handle constraints like the fact that the three stems of a lower case ’m’ should have equal width, a fact that would be very difficult to express generally when dealing with only a contour. On characters, glyphs and typefaces It is important to have the distinction between characters and glyphs clear. A character is an abstract object having a single and unique semantic or phonetic meaning. A glyph represents the visual, graphical appearance of a character. For example, glyphs in different typefaces, such as Times Roman or Zapf Chancery, may be used to represent the character ‘A’. Figure 1 is an example of a kanji glyph which corresponds to characters in several different languages. Figure 1: A kanji glyph (image taken from chapter 6 of the TrueType Reference Manual (Apple Computer, Inc.,