ACM S I G S O F T

Software Engineering Notes vol 25 no 1

January 2000 Page 45

Framework for Debugging Domain-Specific Languages

Premkumar Devanbu University of California Davis, CA 95616
(devanbu@cs.ucdavis.edu)

eral task of "wrapping" command-line oriented legacy systems for inter-operability with H T T P , CORBA [OMG95], etc. So far, we have designed a simple specification language based on pretty-printing [tIug95], to specify wrappers for commandline oriented systems, and we are now implementing a compiler.

References
[DCG+99] P. Devanbu, R. Chen, E. Gansner, H. Muller, and A. Martin. Chime: Customizable hyperlink insertion and maintenance engine for software engineering environments. In International Conference on Software Engineering, 1999. [Dev99] P. Devanbu. Genoa - a customizable, front-end retargetable source code analysis framework. A C M Transactions on Software Engineering and Methodology, 9(2), April 1999. [Hug95] John Hughes. The design of a pretty-printer library. In J. Jeuring and E. Meijer, editors, Advanced Functional Programming, volume 925 of LNCS. Springer Verlag, 1995. [OMG95] OMG. The common object request broker architecture (CORBA)h t t p : / / ~ . omg. org/, 1995. [ZL96] Andreas Zeller and Dorothea Luetkelmus. DDD- a free graphical front-end for unix debuggers. A C M S I G P L A N Notices, January 1996.

Project S u m m a r y
Domain specific languages (DSL), high-level programming languages with constructs expressing precisely the concepts of a specific application domain, can be used to implement entire applications as DSL scripts. DSLs are growing in popularity, and are proving to be an effective means of improving productivity. However, people writing applications in domain specific languages are typically without debugging support and must resort to unpleasant, primitive methods to debug their scripts. Many tools (e.g., parser-generators) support DSL implementation, but a debugger for a DSL still must be built from scratch, without tool support. This project develops a re-usable infrastructure for building DSL debuggers. By analyzing interpreter-based implementations of DSLs, a uniform, general model of the most common features of the data structures found within the run-times of interpreters is developed. The model is then used to leverage a reusable, retargetable debugging framework (comprising a GUI, command interpretation machinery, etc.) that can be added at low cost to an existing interpreter to provide debugging support.

A u t o m a t e d Support for Testing and Debugging of Real-Time Programs Using Oracles 1

Laura K. Dillon Michigan State University East Lansing, MI 48864
(ldillon~cse.msu.edu)

Progress to Date Our work

began around September, 1999, with the award of this one-year grant. Drawing on our experience [Dev99, DCG+99] with retargetable tools in the past, we determined that the most efficient approach to constructing a retargetable debugger to leverage an existing, mature debugging interface and build a retargetable "wrapper" around it. After some investigation, we settled on the DDD [ZL96] tool. DDD is a debugging tool with a well-designed GUI that also offers visualization of common data-types structures such as structures, arrays, pointers, etc. DDD offered several pragmatic advantages: it was available as Open Source, was quite stable and mature, and had already been ported to several different debuggers and interpreters such as Perl, GDB etc., that offer a command-line oriented interface. We observed, however, that the task of porting DDD to a new debugger or interpreter involved quite a bit of intricate wrapping code to deal with parsing and unparsing to the command line interface of the specific debugger or interpreter. So we decided to implement a "wrapper generator" that will support the creation of wrappers for command-line oriented systems. Our short-term goal is to simplify and reduce the task of porting DDD to new debuggers and interpreters. This experience will also help us as we move towards the general problem of a retargetable DSL debugger, a n d produce useful tool as a near-term pay-off. The wrapper-generator may also prove applicable to the more gen-

Project S u m m a r y
This project is investigating the use of oracles created from Graphical Interval Logic (GIL) specifications in testing and debugging of real-time programs. A central focus to date has been on verifying that test executions satisfy temporal specifications. The verification of executions depends on representing specifications as finite-state automata. When an execution violates a specification, we can construct a GIL formula describing a fault in the execution. When displayed graphically, appropriately aligned with an execution trace, this formula helps the user see where in the trace the fault occurred and the nature of the fault. We have also pursued several related methods for modeling and analyzing real-time software systems. We briefly summarize the main research loci over the course of the project to date.

A u t o m a t i c Generation o f Temporal Oracle Generators We developed a general customizable algorithm for producing oracles from temporal logic specifications [DR96]. The algorithm produces oracle generators that are easily tailored to accomodate a variety of temporal operators. Rule instantiation provides a clean mechanism for fine-tuning the
1This work has been supported in part by NSF Grant CCR-9896190.

ACM SIGSOFT

Software Engineering Notes vol 25 no 1

January 2000 Page 46

oracles produce by these generators to reduce computational costs and to supply meaningful feedback about faults.

[KDC99]

Generation of GIL-based Oracles

We investigated two scalable approaches to behavior verification using GIL specifications: direct translation of GIL formulas into non-deterministic finite state machines [ORD96] and instantiation of the parameterizable tableau method discussed above [MDR97]. Tools implementing both methods have been developed for use in experiments to assess the practical utility of the methods and tradeoffs in their use of time and space.

D. Keyes, L. Dillon, and M. Chung. Analysis of a scheduler for a CAD framework. In Proc. 21 st I E E E Intl. Conf. Soft. Eng., pp. 152-162, Los Angeles, May 1999. trace cheva~era for test oracles. In Proe. Intl. Quality Week, pp. 3 - T - 2 , San ~rancisco, May 1997. Software Research Institute.

lMDR97] H. McGuire, L. Dillon, and Y. Ramakrishna. (~enorating

[ORD96] T. O'Malley, D. Richardson, a n d L. Dillon.

Efficient specification-based oracles for critical systems. In Vv'. Seacehi and R. Taylor, eds., Proc. 1996 California Systems Syrup., pp. 50-59, Los Angeles, CA, April 1996.

Heterogeneous System Descriptions

We investigated the use of heterogeneous system descriptions during software development. This work produced a method for analyzing real-time properties of systems in which some components are implemented and others are specified in GIL [ACD98]. The analysis accounts for such properties as runtime overhead, scheduling of processes, and timing properties expressed in GIL.

Adapting Programming Language T e c h n o l o g i e s for F i n i t e - s t a t e Verification 11

Matthew B. Dwyer John Hatcliff Kansas State University Manhattan, KS 66506-2302 ({dwyer,hatcnff}@cis.ksu.edu)
I n t r o d u c t i o n Program verification and program trans-

GIL Specification Patterns

formation are two research areas that have different goals. In another related activity, we extended the temporal speciProgram verificat~ion aims to increase confidence in software fication pattern system of [DAC99] to include mappings for through the use of formal methods and systematic testing. GIL. Program transformation rearranges the structure of programs Case Studies to increase their efficiency or to make them more amenable to some other form of processing. Despite being funded unTwo case studies have been undertaken as part of this project: der different NSF awards from the Software Engineering and A study in modeling and analysis of a planner for a CAD Languages program on the two different areas above the auframework [KDC99] and a study in the definition of oracles thors are collaborating to apply results from both awards to for testing a reliable multicast protocol [Bar99]. develop a set of tools, called Banders, for transforming Java Ongoing Work. programs into a form that is amenable to verification using Implementation of an oracle synthesizer generator is ongo- existing model checking tools. ing. When completed, this tool will be used in experiments T h e O r i g i n s o f B a n d e r a to assess the relative efficiency of various GIL subsets and Finite-state verification refers to a set of techniques for provinterpretations. Research on displaying temporal faults to ing properties of finite-state models of computer systems. users is also underway. The goal of this work is to provide viProperties are specified, for example, with temporal logics, sual feedback to help a user see where and how an execution while systems are specified as finite-state transition systems trace failed and to help her isolate and correct the error(s) of some kind. T0ol support is available for a variety of verithat caused a failure. We are also in the process of designfication techniques, but model checking, with tools like SPIN ing a specification wizard to help system developers create [tio197] and SMV [McM93], is probably the most widely used. the temporal specifications needed for application of various These techniques are attractive because they can be fully aufinite state verification tools. tomated, relieving the user of the need to understand the References inner workings of the verification process. Finite-state verification techniques are especially critical in the development of [ACD98] G. Avrunin, J. Corbett, and L. Dillon. Analyzing partiallyimplemented real-time systems. I E E E Trans. Soft. Eng., concurrent systems, where non-deterministic behavior makes testing especially problematic. 24(8):602-614, Aug. 1998.
[Bar99] F. Barez. A case study in using temporal oracles for testing a n interactive distributed application. MS thesis, Dept. Comp. Sei. & Eng., Michigan State University, East Lansing, MI 48824, May 1999. M. Dwyer, G. Avrunin, a n d J. Corbett. P a t t e r n s in property specifications for finite-state verification. In Proc. ~1st I E E E Intl. Conf. Soft. Eng., pp. 411-421, Los Angeles, May 1999. L. Dillon and Y. Ramakrishna. Generating oracles from your favorite temporal specillcutlons. In Proc. 1996 Syrup. Found. Soft. Eng., pp. 106-117, San Francisco, Oct. 1996.

[DAC99]

For the most part these techniques have not been targeted at reasoning about software systems. This is partly due to the fact that verification grew out of the logic community rather than the programming languages community. The lack of
l l T h i s work was supported in p a r t by NSF's SEL program t h r o u g h C A R E E R award CCR-9703094 ("Engineering High-Quality Concurrent Software"), C A R E E R award CCR-9896354 ("A Partial Evaluation Tool Set for Automatically Customizing Adaptable Software"), and award CCR-9901605 ("A Model Construction Tool Suite for Finite-State Verification of Java"), and by NASA under grant NAG-02-1209.

[DR96]