Comprehension of Generative Techniques * Victor Winter † , Christopher Scalzo, Arpit Jain, Brent Kucera, and Azamatbek Mametjanov Department of Computer Science, University of Nebraska at Omaha A wide variety of tools, techniques, and development methodologies are presently being employed to facilitate the construction of complex software in a timely and cost-effective fashion. In this context, researchers have demonstrated that a number of design and development goals can be satisfied in a framework in which software artifacts are manipulated through generative techniques based on rewriting. This has lead to the creation of tools and environments in which software artifacts can be subjected to sophisticated manipulations. These tools are referred to as software/program transformation systems. In spite of their demonstrated utility, the software industry has been slow in adopting software transformation systems into their development tool set. One reason for this is that the computational model underlying software transformation systems is very different from computational models un- derlying mainstream programming paradigms (e.g., objected oriented programming). As a result, programmers are faced with a considerable learning curve when adding a software transformation system into their development tool set. Benefiting from theoretical advances in recent years, software transformation systems have be- come considerably more sophisticated than their predecessors. This has significantly increased the problem space to which transformation can be effectively applied. Unfortunately, in spite of their theoretical sophistication, software transformation systems generally provide very little support fa- cilitating the comprehension of transformation-based programs. We believe that this presents a bottleneck – both to the experienced transformational programmer as well as to the novice. A par- ticular negative consequence of this is that, as the sophistication of software transformation systems increases, they become more and more inaccessible to mainstream programmers. To address this concern, we are exploring the use of tracing to facilitate the comprehension of software transformation. In this context, transformation is modelled as a sequence of high-level computational steps which we refer to as a trace. We use the term trace element to refer to a computational step within a trace. Broadly speaking, we are interested in the relationships that exist between (1) a transformation source program p, (2) a software artifact being transformed t, and (3) the trace X resulting from the application of p to t. For example, let r : lhs → rhs denote a basic rewrite rule belonging to the program p, let t 1 denote a sub-term in t, and let r ′ denote the trace element in X corresponding to the instance of r that rewrites t 1 to t ′ 1 . Among other things, we are interested in viewing the relationships between (1) r and p, (2) t 1 and t, (3) r ′ and X , (4) r ′ and t 1 , and (5) r ′ and t ′ 1 . Display and navigation are two major issues that arise in our tracing framework. Trace elements may contain complex values (e.g., terms) and, depending on the sophistication of the transformation system, may have a nontrivial relationship to the transformation source program. The software artifact being transformed may have a complex structure defined by an abstract and/or concrete syntax. We are employing graphical as well as symbolic techniques to display these values and structures. * This work was partially supported by the United States Department of Energy under Contract DE-AC04- 94AL85000. Sandia is a multiprogram laboratory operated by Sandia Corporation, a Lockheed Martin Company, for the United States Department of Energy. † vwinter@mail.unomaha.edu 1