Graphical Rewrite Rule Analogies: Avoiding the Inherior Copy & Paste Reuse Dilemma

Therefore, the inclusion of mechanisms to aid the end-user in the location and modification of code that performs a function similar to the one desired greatly improves the usability of domain applications. Reuse mechanisms, such as inheritance in an object-oriented programming approach, are useful to professional programmers but fail to support the occasional programming needs of the end-user. Consequently, a surprisingly high percentage of end-users resort to "copy and paste" approaches for reuse instead of making appropriate use of object-oriented techniques. Visual Analogies are a reuse mechanism for endusers who otherwise would have resorted to "copy and paste." This paper illustrates how visual analogies avoid some of the problems intrinsic to object-oriented programming by eliminating the pitfall of overgeneralization and the need to create non-concrete programming abstractions. By allowing incremental development, objectoriented languages attempt to provide reuse mechanisms such as inheritance. End-users tend to be better at thinking concretely than abstractly [17], and for this reason, inheritance works for professional programmers trained in abstraction processes, but fails to work for end-users. Ideally in an object oriented system, the user locates a promising class in the object class hierarchy and refines it by adding or extending methods to provide the new desired behavior. Few situations approach this ideal, however, and the result is that the user is faced with altering the object hierarchy. It is here that the process breaks down in the face of an inheritance structure defined by someone else. Some behavior of the original objects is desirable, other behavior might be merely superfluous, and still other behavior might be undesirable. THE REUSE DILEMMA: INHERIT OR COPY & PASTE? From an end-user perspective, software reuse takes several forms. Historically, the behavior of most application programs could not be changed or augmented without substantial reprogramming [7]. As techniques emerge to support end-user programming and end-user modifiability, it becomes clear that end-users have little interest in programming computers unless it will help them to build tools that enhance their domain productivity [17]. Several reactions to this phenomenon have emerged. By the object oriented programming community, end-users are often dismissed or forgotten as they grapple unsuccessfully with the complexities of inheritance. Other applications, such as Hypercard, avoid the situation by resorting to inheritance-free representations. For many end-user programmers, this is appealing, although it is a lowest common denominator approach. This "less is more" philosophy of HyperCard has enabled a surprising number of end-users to program. Reuse in HyperCard consists of copy and paste. In this approach, the potentially useful connection between the source and copy is lost. In this paper, we introduce a new reuse approach called Graphical Rewrite Rule Analogies (GRRAs) that are built into the Agentsheets programming substrate [18,19, 20, 21], We contrast Graphical Rewrite Rule Analogies with an object-oriented approach using inheritance in the context of a reuse scenario. Analogies are not limited to graphical rewrite rules and have been explored in AgentSheets most recent programming language called Visual AgentTalk [3]. Finally, we discuss the applicability of GRRAs in the face of analogical brittleness and achievable end-user modifiability. Figure 1. CityTraffic: Trains move on Tracks The following two sections discuss and contrast reuse approaches in the context of the CityTraffic application.