Extending omniscient debugging to support aspect-oriented programming

Pothier, Guillaume; Tanter, Éric

doi:10.1145/1363686.1363753

Cited by 15 publications

(16 citation statements)

References 12 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Several researchers discuss debuggers for aspect-oriented programming (AOP) that provide information closer to the source code, such as the composite source code in Wicca [EAH + 07], the aspect-aware breakpoint model in AODA [DBLJ09], or the identified AOP activities in TOD [PT08]. Nevertheless, all of these debuggers use only the transformed IR of the underlying language.…”

Section: Tools Dedicated To One Languagementioning

confidence: 99%

An In-Depth Look at ALIA4J.

Bockisch¹,

Sewe²,

Yin³

et al. 2012

JOT

View full text Add to dashboard Cite

New programming languages supporting advanced modularization mechanisms are often implemented as transformations to the imperative intermediate representation of an already established language. But while their core constructs largely overlap in semantics, re-using the corresponding transformations requires re-using their syntax as well; this is limiting. In the ALIA4J approach, we identified dispatching as fundamental to most modularization mechanisms and provide a meta-model of dispatching as a rich, extensible intermediate language. Based on this meta-model, one can modularly implement the semantics of dispatchingrelated constructs. From said constructs a single execution model can then be derived which facilitates interpretation, bytecode generation, and even optimized machine-code generation. We show the suitability of our approach by mapping five popular languages to this meta-model and find that most of their constructs are shared across multiple languages. We furthermore present implementations of the three different execution strategies together with a generic visual debugger available to any ALIA4J-based language implementation. Intertwined with this paper is a tutorial-style running example that illustrates our approach.

show abstract

Section: Tools Dedicated To One Languagementioning

confidence: 99%

An In-Depth Look at ALIA4J.

Bockisch¹,

Sewe²,

Yin³

et al. 2012

JOT

View full text Add to dashboard Cite

show abstract

“…Pothier and Tanter [18] implemented an AO debugger based on an open source omniscient Java debugger called TOD. TOD records all events that occur during the execution of a program and the complete history can be inspected and queried offline after the execution.…”

Section: State-of-the-artmentioning

confidence: 99%

“…Several research works discuss AOP debuggers to provide information closer to the source code, such as the composite source code in Wicca [11], the aspect-aware break-point model in AODA [10], or the identified AOP activities in TOD [18]. Nevertheless, all of these debuggers use only the woven IR of the underlying language.…”

Section: Introductionmentioning

confidence: 99%

A fine-grained debugger for aspect-oriented programming

Yin

Bockisch

Akşit

2012

Proceedings of the 11th Annual International Conference on Aspect-Oriented Software Development

View full text Add to dashboard Cite

To increase modularity, aspect-oriented programming provides a mechanism based on implicit invocation: An aspect can influence runtime behavior of other modules without the need that these modules refer to the aspect. Recent studies show that a significant part of reported bugs in aspectoriented programs are caused exactly by this implicitness. These bugs are difficult to detect because aspect-oriented source code elements and their locations are transformed or even lost after compilation. We investigate four dedicated fault models and identify ten tasks that a debugger should be able to perform for detecting aspect-orientation-specific faults. We show that existing debuggers are not powerful enough to support all identified tasks because the aspectoriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate representation preserving the abstraction level of aspect-oriented source code. We define a debugging model which is aware of aspect-oriented concepts. Based on the model, we implement a user interface with functionalities supporting the identified tasks, like visualizing pointcut evaluation and program composition.

show abstract

“…Aspect-Oriented Programming (AOP) [24] can be viewed as an enhancement technology, and several approaches aim at debugging support for AOP [14,34,22]. However, debugging aspect-oriented programs is different from debugging transparently enhanced programs.…”

Section: Debugging Transformed Codementioning

confidence: 99%

Enhancing source-level programming tools with an awareness of transparent program transformations

Song

Tilevich

2009

SIGPLAN Not.

View full text Add to dashboard Cite

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.

show abstract

Extending omniscient debugging to support aspect-oriented programming

Cited by 15 publications

References 12 publications

An In-Depth Look at ALIA4J.

An In-Depth Look at ALIA4J.

A fine-grained debugger for aspect-oriented programming

Enhancing source-level programming tools with an awareness of transparent program transformations

Contact Info

Product

Resources

About