In systems software, the C preprocessor is heavily used to manage variability and improve efficiency. It is the primary tool to model crosscutting concerns in a very fine-grained way, but leads to extremely tangled and scattered preprocessor code. In this paper, we explore the process of aspect mining and extraction in the context of preprocessor-driven systems. Our aim is to identify both opportunities (extracting conditional compilation into advice) and pitfalls (mining on unpreprocessed code) in migrating preprocessor code to aspects. We distill five trade-offs which give a first impression about the usefulness of replacing the preprocessor by aspects. Preprocessor-driven systems prove to be a real challenge for aspect mining, but they could become on the other hand one of the most promising applications of AOP.
{"title":"Aspect mining in the presence of the C preprocessor","authors":"Bram Adams, B. Rompaey, Celina Berg, Y. Coady","doi":"10.1145/1404953.1404954","DOIUrl":"https://doi.org/10.1145/1404953.1404954","url":null,"abstract":"In systems software, the C preprocessor is heavily used to manage variability and improve efficiency. It is the primary tool to model crosscutting concerns in a very fine-grained way, but leads to extremely tangled and scattered preprocessor code. In this paper, we explore the process of aspect mining and extraction in the context of preprocessor-driven systems. Our aim is to identify both opportunities (extracting conditional compilation into advice) and pitfalls (mining on unpreprocessed code) in migrating preprocessor code to aspects. We distill five trade-offs which give a first impression about the usefulness of replacing the preprocessor by aspects. Preprocessor-driven systems prove to be a real challenge for aspect mining, but they could become on the other hand one of the most promising applications of AOP.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122752888","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
A large part of the software development effort is typically spent on maintenance and evolution, namely on adding new and unanticipated features. As aspect-oriented programming (AOP) can be easily used to compose software in non-planned ways, many researchers are investigating AOP as a technique that can play an important role in this particular field. However, unexpected interactions between aspects are still a major problem that compromise AOP's applicability, especially in large projects where many developers, often including new team members, are involved in the process. This paper addresses the issues of aspect conflicts and interactions and proposes a technique to help compose aspects in a disciplined way using a test-driven development approach. A simple example for a banking system helps on illustrating the technique.
{"title":"Disciplined composition of aspects using tests","authors":"André Restivo, Ademar Aguiar","doi":"10.1145/1404953.1404961","DOIUrl":"https://doi.org/10.1145/1404953.1404961","url":null,"abstract":"A large part of the software development effort is typically spent on maintenance and evolution, namely on adding new and unanticipated features. As aspect-oriented programming (AOP) can be easily used to compose software in non-planned ways, many researchers are investigating AOP as a technique that can play an important role in this particular field. However, unexpected interactions between aspects are still a major problem that compromise AOP's applicability, especially in large projects where many developers, often including new team members, are involved in the process. This paper addresses the issues of aspect conflicts and interactions and proposes a technique to help compose aspects in a disciplined way using a test-driven development approach. A simple example for a banking system helps on illustrating the technique.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114507245","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Crosscutting concerns appear in software system due to the inherent inadequacy of OOP mechanisms to capture them in suitable encapsulating units. This results in scattered and tangled code. One more form of scattering and tangling may result from the absence of OOP abstractions for domain entities of a software. These non-encapsulated domain entities end up scattered and tangled, appearing as crosscutting concerns in code. Aspect mining techniques automate the task of search for possible aspects in the code and falsely attribute all the crosscutting code to aspects even when these scattered concerns point to the absence of a domain abstraction. This paper discusses the application of aspect mining in the presence crosscutting code originating from the absence of aspects and OOP abstractions. A roadmap of a possible solution is provided to distinguish these two types of code scattering.
{"title":"Mining and classification of diverse crosscutting concerns","authors":"M. U. Bhatti, Stéphane Ducasse","doi":"10.1145/1404953.1404955","DOIUrl":"https://doi.org/10.1145/1404953.1404955","url":null,"abstract":"Crosscutting concerns appear in software system due to the inherent inadequacy of OOP mechanisms to capture them in suitable encapsulating units. This results in scattered and tangled code. One more form of scattering and tangling may result from the absence of OOP abstractions for domain entities of a software. These non-encapsulated domain entities end up scattered and tangled, appearing as crosscutting concerns in code. Aspect mining techniques automate the task of search for possible aspects in the code and falsely attribute all the crosscutting code to aspects even when these scattered concerns point to the absence of a domain abstraction. This paper discusses the application of aspect mining in the presence crosscutting code originating from the absence of aspects and OOP abstractions. A roadmap of a possible solution is provided to distinguish these two types of code scattering.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129714378","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Crosscutting concerns in object-oriented programming hinder evolution because of their symptoms: tangling and scattering. To benefit from the modularisation capabilities for crosscutting concerns provided by aspect-oriented programming (which prevent tangling and scattering) aspect-introducing refactoring can be used. The first step in aspect-introducing refactoring is identifying and documenting crosscutting concerns in existing code. The second step is refactoring the identified concerns to aspects. This paper describes a tool called SAIR that can perform the second step of the aspect-introducing refactoring. For the first step, documenting, SAIR uses crosscutting concern sorts. Of the various possible sorts, SAIR currently supports the two most commonly encountered ones: Role Superimposition and Consistent Behavior. The refactoring towards aspects of concerns of these sorts is illustrated on an open source application (JHotDraw).
{"title":"Sort-based refactoring of crosscutting concerns to aspects","authors":"Robin van der Rijst, M. Marin, A. Deursen","doi":"10.1145/1404953.1404957","DOIUrl":"https://doi.org/10.1145/1404953.1404957","url":null,"abstract":"Crosscutting concerns in object-oriented programming hinder evolution because of their symptoms: tangling and scattering. To benefit from the modularisation capabilities for crosscutting concerns provided by aspect-oriented programming (which prevent tangling and scattering) aspect-introducing refactoring can be used. The first step in aspect-introducing refactoring is identifying and documenting crosscutting concerns in existing code. The second step is refactoring the identified concerns to aspects.\u0000 This paper describes a tool called SAIR that can perform the second step of the aspect-introducing refactoring. For the first step, documenting, SAIR uses crosscutting concern sorts. Of the various possible sorts, SAIR currently supports the two most commonly encountered ones: Role Superimposition and Consistent Behavior. The refactoring towards aspects of concerns of these sorts is illustrated on an open source application (JHotDraw).","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126051470","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Aspect-oriented software evolution introduces new challenges for regression test selection. When a program, that has been thoroughly tested, evolves by addition of an aspect, it is important for regression test selection to know which test cases are impacted by the new aspects and which are not. The work presented here proposes a classification for regression test cases and introduces an algorithm for impact analysis of aspects on a set of test cases. A major benefit of this analysis is that it saves the execution of test cases that are not impacted.
{"title":"Regression test selection when evolving software with aspects","authors":"Romain Delamare, B. Baudry, Yves Le Traon","doi":"10.1145/1404953.1404960","DOIUrl":"https://doi.org/10.1145/1404953.1404960","url":null,"abstract":"Aspect-oriented software evolution introduces new challenges for regression test selection. When a program, that has been thoroughly tested, evolves by addition of an aspect, it is important for regression test selection to know which test cases are impacted by the new aspects and which are not. The work presented here proposes a classification for regression test cases and introduces an algorithm for impact analysis of aspects on a set of test cases. A major benefit of this analysis is that it saves the execution of test cases that are not impacted.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121234447","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. If regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes. In this paper, we present Flota, a fault localization tool for AspectJ programs. When a regression test fails unexpectedly after a session of source changes, Flota first decomposes the differences between two program versions into a set of atomic changes, and then identifies a subset of affecting changes which is responsible for the failure. Programmers are allowed to select (and apply) suspected changes to the original program, constructing compliable intermediate versions. Thus, programmers can re-execute the failed test against these intermediate program versions to locate the exact faulty changes by iteratively selecting, applying and narrowing down the set of affecting changes. Flota is implemented on top of the ajc compiler and designed as an eclipse plugin. Our preliminary empirical study shows that Flota can assist programmers effectively to find a small set of faulty changes and provide valuable debugging support.
{"title":"Flota: a programmer assistant for locating faulty changes in AspectJ software evolution","authors":"Sai Zhang, Zhongxian Gu, Yu Lin, Jianjun Zhao","doi":"10.1145/1404953.1404959","DOIUrl":"https://doi.org/10.1145/1404953.1404959","url":null,"abstract":"As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. If regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes. In this paper, we present Flota, a fault localization tool for AspectJ programs. When a regression test fails unexpectedly after a session of source changes, Flota first decomposes the differences between two program versions into a set of atomic changes, and then identifies a subset of affecting changes which is responsible for the failure. Programmers are allowed to select (and apply) suspected changes to the original program, constructing compliable intermediate versions. Thus, programmers can re-execute the failed test against these intermediate program versions to locate the exact faulty changes by iteratively selecting, applying and narrowing down the set of affecting changes. Flota is implemented on top of the ajc compiler and designed as an eclipse plugin. Our preliminary empirical study shows that Flota can assist programmers effectively to find a small set of faulty changes and provide valuable debugging support.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126260118","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Dynamic software evolution represents a viable technique to update software systems at run-time. On-the-fly updating is particularly helpful for systems that must be continuously available and up-to-date. Updates consist of several incremental changes that must be applied to a system. These individual changes exhibit symptoms similar to crosscutting concerns: they are typically scattered across several classes. We therefore leverage aspect technology and use aspects to encapsulate the changes constituting an update. In addition, dynamic aspect systems can serve as a practicable platform to inject updates at run-time. In this paper, we present how we extract the updating aspects for a dynamic aspect system. We detail the algorithms necessary to generate such updating aspects that rely on the computation of the dependences between the changes to determine the granularity of an aspect.
{"title":"Extracting updating aspects from version differences","authors":"S. Previtali, T. Gross","doi":"10.1145/1404953.1404958","DOIUrl":"https://doi.org/10.1145/1404953.1404958","url":null,"abstract":"Dynamic software evolution represents a viable technique to update software systems at run-time. On-the-fly updating is particularly helpful for systems that must be continuously available and up-to-date. Updates consist of several incremental changes that must be applied to a system. These individual changes exhibit symptoms similar to crosscutting concerns: they are typically scattered across several classes. We therefore leverage aspect technology and use aspects to encapsulate the changes constituting an update. In addition, dynamic aspect systems can serve as a practicable platform to inject updates at run-time. In this paper, we present how we extract the updating aspects for a dynamic aspect system. We detail the algorithms necessary to generate such updating aspects that rely on the computation of the dependences between the changes to determine the granularity of an aspect.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115364933","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
A crosscutting concern is often implemented based on a coding pattern, or a particular sequence of method calls and control statements. We have applied a sequential pattern mining algorithm to capture coding patterns in Java programs. We have manually investigated the resultant patterns that involve both crosscutting concerns and implementation idioms. This paper discusses the detail of our pattern mining algorithm and reports detected crosscutting concerns.
{"title":"Mining application-specific coding patterns for software maintenance","authors":"T. Ishio, H. Date, Tatsuya Miyake, Katsuro Inoue","doi":"10.1145/1404953.1404956","DOIUrl":"https://doi.org/10.1145/1404953.1404956","url":null,"abstract":"A crosscutting concern is often implemented based on a coding pattern, or a particular sequence of method calls and control statements. We have applied a sequential pattern mining algorithm to capture coding patterns in Java programs. We have manually investigated the resultant patterns that involve both crosscutting concerns and implementation idioms. This paper discusses the detail of our pattern mining algorithm and reports detected crosscutting concerns.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2008-03-31","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127508693","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper proposes test-based pointcuts, a new aspect-oriented programming language construct that uses unit test cases as interface of crosscutting concerns. A test-based pointcut primarily specifies a set of test cases associated to a program. At execution time, it matches the join points that have the same execution history to the one of the specified test cases. The test-based approach improves pointcut definitions in two respects. First, test-based pointcuts are less fragile with respect to program changes because rather than directly relying on type and operation names in a program, they indirectly specify join points through unit test cases, which are easier to be kept up-to-date. Second, test-based pointcuts can discriminate execution histories without requiring to specify detailed execution steps, as they use test cases as abstractions of execution histories. With the abstractions, the second respect contributes to the first respect. We designed and implemented the test-based pointcuts as an extension to AspectJ, and confirmed, through an case study, test-based pointcuts are more robust against evolution when used for a practical application program.
{"title":"Test-based pointcuts: a robust pointcut mechanism based on unit test cases for software evolution","authors":"K. Sakurai, H. Masuhara","doi":"10.1145/1275672.1275677","DOIUrl":"https://doi.org/10.1145/1275672.1275677","url":null,"abstract":"This paper proposes test-based pointcuts, a new aspect-oriented programming language construct that uses unit test cases as interface of crosscutting concerns. A test-based pointcut primarily specifies a set of test cases associated to a program. At execution time, it matches the join points that have the same execution history to the one of the specified test cases. The test-based approach improves pointcut definitions in two respects. First, test-based pointcuts are less fragile with respect to program changes because rather than directly relying on type and operation names in a program, they indirectly specify join points through unit test cases, which are easier to be kept up-to-date. Second, test-based pointcuts can discriminate execution histories without requiring to specify detailed execution steps, as they use test cases as abstractions of execution histories. With the abstractions, the second respect contributes to the first respect. We designed and implemented the test-based pointcuts as an extension to AspectJ, and confirmed, through an case study, test-based pointcuts are more robust against evolution when used for a practical application program.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2007-03-12","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126258419","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Speed is a necessity in low-level systems software. Mechanisms through which it is achieved are often at odds with well-known practices in terms of evolution and maintenance tasks. Ironically, though these mechanisms often create adverse code conditions, in practice they thinly veil structural support associated with language mechanisms for both Object-Oriented (OO) and Aspect-Oriented (AO) programming. This paper argues for aggressive and comprehensive tools designed to provide support necessary for developers to take control in this high-speed, low-level systems domain. Through these tools, we envision evolving highly configurable single-source systems according to high-level structural principles, without imposing any speed limits on their underlying code.
{"title":"Surrendering to the need for speed while maintaining visibility in adverse code conditions","authors":"Celina Berg, J. Proctor, Y. Coady","doi":"10.1145/1275672.1275674","DOIUrl":"https://doi.org/10.1145/1275672.1275674","url":null,"abstract":"Speed is a necessity in low-level systems software. Mechanisms through which it is achieved are often at odds with well-known practices in terms of evolution and maintenance tasks. Ironically, though these mechanisms often create adverse code conditions, in practice they thinly veil structural support associated with language mechanisms for both Object-Oriented (OO) and Aspect-Oriented (AO) programming. This paper argues for aggressive and comprehensive tools designed to provide support necessary for developers to take control in this high-speed, low-level systems domain. Through these tools, we envision evolving highly configurable single-source systems according to high-level structural principles, without imposing any speed limits on their underlying code.","PeriodicalId":210171,"journal":{"name":"LATE@AOSD","volume":null,"pages":null},"PeriodicalIF":0.0,"publicationDate":"2007-03-12","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"114975941","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：