Debugging Aspect-Enabled Programs

Eaddy, Marc; Aho, Alfred V.; Hu, Weiping; McDonald, P. H.; Burger, Julian

doi:10.1007/978-3-540-77351-1_17

Cited by 28 publications

(35 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Each method-called snippet in DiSL terminology-is annotated so as to specify the join points where the code of the snippet shall be inlined. 3 The profiler instrumentation code on Figure 1 uses two such snippets, the first one prints the entry time, the second one the exit time.…”

Section: Methods Execution Time Profilermentioning

confidence: 99%

See 1 more Smart Citation

Introduction to dynamic program analysis with DiSL

Marek

Zheng

Ansaloni

et al. 2013

Proceedings of the 4th ACM/SPEC International Conference on Performance Engineering

View full text Add to dashboard Cite

Dynamic program analysis (DPA) tools assist in many software engineering and development tasks, including profiling, program comprehension, and performance model construction and calibration. On the Java platform, many DPA tools are implemented either using aspect-oriented programming (AOP), or rely on bytecode instrumentation to modify the base program code. The pointcut/advice model found in AOP enables rapid tool development, but does not allow expressing certain instrumentations due to limitations of mainstream AOP languages-developers thus use bytecode manipulation to gain more expressiveness and performance. However, while the existing bytecode manipulation libraries handle some low-level details, they still make tool development tedious and error-prone. Targeting this issue, we provide the first complete presentation of DiSL, an open-source instrumentation framework that reconciles the conciseness of the AOP pointcut/advice model and the expressiveness and performance achievable with bytecode manipulation libraries. Specifically, we extend our previous work to provide an overview of the DiSL architecture, advanced features, and the programming model. We also include case studies illustrating successful deployment of DiSL-based DPA tools.

show abstract

Section: Methods Execution Time Profilermentioning

confidence: 99%

“…The existing DPA tools can aid in a variety of tasks, including profiling [1,2], debugging [3,4,5,6], and program comprehension [7,8], with increasingly sophisticated tools being introduced by the research community.…”

Section: Introductionmentioning

confidence: 99%

Introduction to dynamic program analysis with DiSL

Marek

Zheng

Ansaloni

et al. 2013

Proceedings of the 4th ACM/SPEC International Conference on Performance Engineering

View full text Add to dashboard Cite

show abstract

“…Wicca [11] is a dynamic AOP system for C# applications that performs source weaving at runtime. For debugging purposes, the woven source code can be inspected, e.g., for checking if programs are correctly composed.…”

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

Proceedings of the 24th ACM SIGPLAN Conference on Object Oriented Programming Systems Languages and Applications

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

Debugging Aspect-Enabled Programs

Cited by 28 publications

References 21 publications

Introduction to dynamic program analysis with DiSL

Introduction to dynamic program analysis with DiSL

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