A fine-grained, customizable debugger for aspect-oriented programming

Haihan Yin, G.T. Leavens (Editor), S. Chiba (Editor), Christoph Bockisch, Mehmet Aksit, E. Tanter (Editor)

    Research output: Contribution to journalArticleAcademicpeer-review

    1 Citation (Scopus)

    Abstract

    To increase modularity, many aspect-oriented programming languages provide 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 aspect-oriented 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 11 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 aspect- oriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate represen- tation preserving the abstraction level of aspect-oriented source code. This is based on a model of the more general formalism of advanced dispatching. Based on this model, we implement a user interface with functionalities supporting the identified tasks, such as visualizing point- cut evaluation and program composition. Due to the generality of our intermediate representation, our debugger can be used for a wide range of programming languages. To account for the syntactic differences among these languages, we allow language designers to customize the textual representations on the user interface.
    Original languageUndefined
    Pages (from-to)1-38
    Number of pages38
    JournalTransactions on aspect-oriented software development
    Volume7800
    DOIs
    Publication statusPublished - 2013

    Keywords

    • customizable visualization
    • EWI-23201
    • CR-D.2.3
    • Aspect Oriented Programming
    • METIS-296372
    • IR-85425
    • Debugging

    Cite this

    Yin, Haihan ; Leavens, G.T. (Editor) ; Chiba, S. (Editor) ; Bockisch, Christoph ; Aksit, Mehmet ; Tanter, E. (Editor). / A fine-grained, customizable debugger for aspect-oriented programming. In: Transactions on aspect-oriented software development. 2013 ; Vol. 7800. pp. 1-38.
    @article{51d04c4967664873bac058913d65c0dd,
    title = "A fine-grained, customizable debugger for aspect-oriented programming",
    abstract = "To increase modularity, many aspect-oriented programming languages provide 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 aspect-oriented 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 11 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 aspect- oriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate represen- tation preserving the abstraction level of aspect-oriented source code. This is based on a model of the more general formalism of advanced dispatching. Based on this model, we implement a user interface with functionalities supporting the identified tasks, such as visualizing point- cut evaluation and program composition. Due to the generality of our intermediate representation, our debugger can be used for a wide range of programming languages. To account for the syntactic differences among these languages, we allow language designers to customize the textual representations on the user interface.",
    keywords = "customizable visualization, EWI-23201, CR-D.2.3, Aspect Oriented Programming, METIS-296372, IR-85425, Debugging",
    author = "Haihan Yin and G.T. Leavens and S. Chiba and Christoph Bockisch and Mehmet Aksit and E. Tanter",
    note = "eemcs-eprint-23201",
    year = "2013",
    doi = "10.1007/978-3-642-36964-3_1",
    language = "Undefined",
    volume = "7800",
    pages = "1--38",
    journal = "Transactions on aspect-oriented software development",
    issn = "1864-3027",
    publisher = "Springer",

    }

    A fine-grained, customizable debugger for aspect-oriented programming. / Yin, Haihan; Leavens, G.T. (Editor); Chiba, S. (Editor); Bockisch, Christoph; Aksit, Mehmet; Tanter, E. (Editor).

    In: Transactions on aspect-oriented software development, Vol. 7800, 2013, p. 1-38.

    Research output: Contribution to journalArticleAcademicpeer-review

    TY - JOUR

    T1 - A fine-grained, customizable debugger for aspect-oriented programming

    AU - Yin, Haihan

    AU - Bockisch, Christoph

    AU - Aksit, Mehmet

    A2 - Leavens, G.T.

    A2 - Chiba, S.

    A2 - Tanter, E.

    N1 - eemcs-eprint-23201

    PY - 2013

    Y1 - 2013

    N2 - To increase modularity, many aspect-oriented programming languages provide 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 aspect-oriented 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 11 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 aspect- oriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate represen- tation preserving the abstraction level of aspect-oriented source code. This is based on a model of the more general formalism of advanced dispatching. Based on this model, we implement a user interface with functionalities supporting the identified tasks, such as visualizing point- cut evaluation and program composition. Due to the generality of our intermediate representation, our debugger can be used for a wide range of programming languages. To account for the syntactic differences among these languages, we allow language designers to customize the textual representations on the user interface.

    AB - To increase modularity, many aspect-oriented programming languages provide 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 aspect-oriented 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 11 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 aspect- oriented abstractions are lost after compilation. This paper describes the design and implementation of a debugger for aspect-oriented languages using a dedicated intermediate represen- tation preserving the abstraction level of aspect-oriented source code. This is based on a model of the more general formalism of advanced dispatching. Based on this model, we implement a user interface with functionalities supporting the identified tasks, such as visualizing point- cut evaluation and program composition. Due to the generality of our intermediate representation, our debugger can be used for a wide range of programming languages. To account for the syntactic differences among these languages, we allow language designers to customize the textual representations on the user interface.

    KW - customizable visualization

    KW - EWI-23201

    KW - CR-D.2.3

    KW - Aspect Oriented Programming

    KW - METIS-296372

    KW - IR-85425

    KW - Debugging

    U2 - 10.1007/978-3-642-36964-3_1

    DO - 10.1007/978-3-642-36964-3_1

    M3 - Article

    VL - 7800

    SP - 1

    EP - 38

    JO - Transactions on aspect-oriented software development

    JF - Transactions on aspect-oriented software development

    SN - 1864-3027

    ER -