Domain-specific languages (DSLs) assist a software developer (or end-user) in writing a program using idioms that are similar to the abstractions found in a specific problem domain. Testing tool support for DSLs is lacking when compared to the capabilities provided for standard general-purpose languages (GPLs), such as Java and C++. For example, support for debugging and unit testing a program written in a DSL is often non-existent. The lack of a debugger and unit test engine at the proper abstraction level limits an end-user‟s ability to discover and locate faults in a DSL program. This dissertation describes a grammar-driven technique to build a debugging and unit testing tool generation framework by adaptations to existing DSL grammars. This approach leverages existing GPL testing tools to indirectly exercise the end-user‟s debug and test intentions at the DSL level. The adaptations to DSL grammars represent the hooks needed to interface with a supporting infrastructure constructed for an Integrated Development Environment (IDE) that assists in debugging and unit testing a program written in a DSL. The contribution represents a coordinated approach to bring essential

Abstract. The ability to debug programs composed using aspect-oriented programming (AOP) techniques is critical to the adoption of AOP. Nevertheless, many AOP systems lack adequate support for debugging, making it difficult to diagnose faults and understand the program‘s composition and control flow. We present an AOP debug model that characterizes AOP-specific program composition techniques and AOP-specific program behaviors, and relates them to the AOP-specific faults they induce. We specify debugging criteria that we feel all AOP systems should support and compare how several AOP systems measure up to this ideal. We explain why AOP composition techniques, particularly dynamic and binary weaving, hinder source-level debugging, and how results from related research on debugging optimized code help solve the problem. We also present Wicca, the first dynamic AOP system to support full source-level debugging. We demonstrate how Wicca‘s powerful interactive debugging features allow a programmer to quickly diagnose faults in the base program behavior or AOPspecific behavior. 1

Both component frameworks and domain-specific languages aim to promote reuse and enhance product-line software development, but they approach the problem from different viewpoints. This paper provides motivation and hypothesis for comparison between the two paradigms. As a result we note some initial observations of the paradigms and present research questions for an empirical study.

Non-Transparent Debugging of Optimized Code by Caroline Mae Tice Doctor of Philosophy in Computer Science University of California at Berkeley Professor Susan L. Graham, Chair Debugging optimized code is a problem for which a widely accepted solution has yet to be found. Over the years many approaches have been suggested, including limiting the compiler optimizations, restricting the debugger functionality, using recompilation or dynamic de-optimization to undo the optimizations, and having the debugger determine the e#ects of optimizations and mask them from the user. All of these approaches have a common thread: they place a barrier between the user and the optimizations, either altering, undoing, or hiding the e#ects of optimizations.

Programs written in managed languages are compiled to a platform-independent intermediate representation, such as Java bytecode. The relative high level of Java bytecode has engendered a widespread practice of changing the bytecode directly, without modifying the maintained version of the source code. This practice, called bytecode engineering or enhancement, has become indispensable in introducing various concerns, including persistence, distribution, and security, transparently. For example, transparent persistence architectures help avoid the entanglement of business and persistence logic in the source code by changing the bytecode directly to synchronize objects with stable storage. With functionality added directly at the bytecode level, the source code reflects only partial semantics of the program. Specifically, the programmer can neither ascertain the program’s runtime behavior by browsing its source code, nor map the runtime behavior back to the original source code. This paper presents an approach that improves the utility of source-level programming tools by providing enhancement specifications written in a domain-specific language. By interpreting the specifications, a source-level programming tool can gain an awareness of the bytecode enhancements and improve its precision and usability. We demonstrate the applicability of our approach by making a source code editor and a symbolic debugger enhancements-aware.