A fine-grained debugger for aspect-oriented programming

Haihan Yin, Christoph Bockisch, Mehmet Akşit

    Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

    7 Citations (Scopus)
    4 Downloads (Pure)

    Abstract

    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 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 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 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 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.
    Original languageEnglish
    Title of host publicationAOSD '12
    Subtitle of host publicationProceedings of the 11th Annual International Conference on Aspect-oriented Software Development
    Place of PublicationNew York, NY
    PublisherAssociation for Computing Machinery (ACM)
    Pages59-70
    Number of pages12
    ISBN (Print)978-1-4503-1092-5
    DOIs
    Publication statusPublished - 25 Mar 2012
    Event11th International Conference on Aspect-Oriented Software Development, AOSD 2012 - Potsdam, Germany
    Duration: 24 Mar 201230 Mar 2012
    Conference number: 11
    http://aosd.net/2012/

    Conference

    Conference11th International Conference on Aspect-Oriented Software Development, AOSD 2012
    Abbreviated titleAOSD
    CountryGermany
    CityPotsdam
    Period24/03/1230/03/12
    Internet address

    Fingerprint

    Aspect oriented programming
    User interfaces
    Chemical analysis

    Keywords

    • METIS-296117
    • Advanced dispatching
    • AOP
    • IR-83373
    • EWI-22382
    • Debugger
    • fine-grained intermediate representation
    • ﬿ne-grained intermediate representation
    • Visualization

    Cite this

    Yin, H., Bockisch, C., & Akşit, M. (2012). A fine-grained debugger for aspect-oriented programming. In AOSD '12: Proceedings of the 11th Annual International Conference on Aspect-oriented Software Development (pp. 59-70). New York, NY: Association for Computing Machinery (ACM). https://doi.org/10.1145/2162049.2162057
    Yin, Haihan ; Bockisch, Christoph ; Akşit, Mehmet . / A fine-grained debugger for aspect-oriented programming. AOSD '12: Proceedings of the 11th Annual International Conference on Aspect-oriented Software Development. New York, NY : Association for Computing Machinery (ACM), 2012. pp. 59-70
    @inproceedings{e1cd5dd25de54ddcad94d27cf77907aa,
    title = "A fine-grained debugger for aspect-oriented programming",
    abstract = "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 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 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 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 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.",
    keywords = "METIS-296117, Advanced dispatching, AOP, IR-83373, EWI-22382, Debugger, fine-grained intermediate representation, ﬿ne-grained intermediate representation, Visualization",
    author = "Haihan Yin and Christoph Bockisch and Mehmet Akşit",
    year = "2012",
    month = "3",
    day = "25",
    doi = "10.1145/2162049.2162057",
    language = "English",
    isbn = "978-1-4503-1092-5",
    pages = "59--70",
    booktitle = "AOSD '12",
    publisher = "Association for Computing Machinery (ACM)",
    address = "United States",

    }

    Yin, H, Bockisch, C & Akşit, M 2012, A fine-grained debugger for aspect-oriented programming. in AOSD '12: Proceedings of the 11th Annual International Conference on Aspect-oriented Software Development. Association for Computing Machinery (ACM), New York, NY, pp. 59-70, 11th International Conference on Aspect-Oriented Software Development, AOSD 2012, Potsdam, Germany, 24/03/12. https://doi.org/10.1145/2162049.2162057

    A fine-grained debugger for aspect-oriented programming. / Yin, Haihan; Bockisch, Christoph; Akşit, Mehmet .

    AOSD '12: Proceedings of the 11th Annual International Conference on Aspect-oriented Software Development. New York, NY : Association for Computing Machinery (ACM), 2012. p. 59-70.

    Research output: Chapter in Book/Report/Conference proceedingConference contributionAcademicpeer-review

    TY - GEN

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

    AU - Yin, Haihan

    AU - Bockisch, Christoph

    AU - Akşit, Mehmet

    PY - 2012/3/25

    Y1 - 2012/3/25

    N2 - 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 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 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 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 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.

    AB - 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 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 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 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 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.

    KW - METIS-296117

    KW - Advanced dispatching

    KW - AOP

    KW - IR-83373

    KW - EWI-22382

    KW - Debugger

    KW - fine-grained intermediate representation

    KW - ﬿ne-grained intermediate representation

    KW - Visualization

    U2 - 10.1145/2162049.2162057

    DO - 10.1145/2162049.2162057

    M3 - Conference contribution

    SN - 978-1-4503-1092-5

    SP - 59

    EP - 70

    BT - AOSD '12

    PB - Association for Computing Machinery (ACM)

    CY - New York, NY

    ER -

    Yin H, Bockisch C, Akşit M. A fine-grained debugger for aspect-oriented programming. In AOSD '12: Proceedings of the 11th Annual International Conference on Aspect-oriented Software Development. New York, NY: Association for Computing Machinery (ACM). 2012. p. 59-70 https://doi.org/10.1145/2162049.2162057