[show abstract][hide abstract] ABSTRACT: One of the aims of Aspect-Oriented Requirements Engineering is to ad- dress the composability and subsequent analysis of crosscutting and non-crosscutting concerns during requirements engineering. A composition definition explicitly rep- resents interdependencies and interactions between concerns. Subsequent analysis of such compositions helps to reveal conflicting dependencies that need to be resolved in requirements. However, detecting conflicts in a large set of textual aspect-oriented requirements is a difficult task as a large number of explicitly defined interdependen- cies need to be analyzed. This paper presents EA-Analyzer, the first automated tool for identifying conflicts in aspect-oriented requirements specified in natural-language text. The tool is based on a novel application of a Bayesian learning method. We present an empirical evaluation of the tool with three industrial-strength requirements documents from different domains and a fourth academic case study used as a de facto benchmark in several areas of the aspect-oriented community. This evaluation shows that the tool achieves up to 93.90 % accuracy regardless of the documents chosen as the training and validation sets.
[show abstract][hide abstract] ABSTRACT: Early aspects are crosscutting concerns that are identified and addressed at the requirements and architecture level, while code aspects are crosscutting concerns that manifest at the code level. Currently, there are many approaches to address the identification and modularization of these cross- cutting concerns at each level, but very few techniques try to analyze the relationship between early aspects and code as- pects. This paper presents a tool for automating the process of identifying traceability links between requirements-level aspects and code aspects, which is a first step towards an analysis of the relationship between the early aspects and code aspects. We also present an empirical evaluation of the tool with a real-life Web-based information system and a software product line for handling data on mobile devices. The results show that we can identify traceability links be- tween early aspects and code aspects with a high accuracy.
[show abstract][hide abstract] ABSTRACT: Aspect-Oriented Programming (AOP) has introduced a complementary set of mechanisms which enhance the modularisation of crosscutting concerns. However, such mechanisms represent new potential sources of faults that may be systematically tackled with mutation testing. In this demonstration we present a tool, named Proteum/AJ, which automates the mutation testing of AspectJ programs. Proteum/AJ supports the main steps of this testing approach and realises a set of requirements for mutation-based testing tools like mutant handling, test case handling and mutant analysis. Our experience in using the tool provided us with evidence on the feasibility of performing mutation testing of AO programs. In this demonstration we are going to share some of this experience with the audience.
Companion Volume of the 10th International Conference on Aspect-Oriented Software Development, AOSD 2011, Porto de Galinhas, Brazil, March 21-25, 2011; 01/2011
[show abstract][hide abstract] ABSTRACT: In this chapter, we examine the phenomenon of imperfect information, the problems it causes during SPL engineering and we outline a generalised approach for addressing these problems. In the final section of this chapter we will examine the way forward for achieving life-cycle wide supprt for imperfect information in SPL engineering.
[show abstract][hide abstract] ABSTRACT: Due to the very large number of configurations that can typically be derived from a Dynamic Software Product Line (DSPL), efficient and effective testing of such systems have become a major challenge for software developers. In particular, when a configuration needs to be deployed quickly due to rapid contextual changes (e.g., in an unfolding crisis), time constraints hinder the proper testing of such a configuration. In this paper, we propose to reduce the testing required of such DSPLs to a relevant subset of configurations. Whenever a need to adapt to an untested configuration is encountered, our approach determines the most similar tested configuration and reuses its test results to either obtain a coverage measure or infer a confidence degree for the new, untested configuration. We focus on providing these techniques for inference of structural testing results for DSPLs, which is supported by an early prototype implementation.
SIGSOFT/FSE'11 19th ACM SIGSOFT Symposium on the Foundations of Software Engineering (FSE-19) and ESEC'11: 13rd European Software Engineering Conference (ESEC-13), Szeged, Hungary, September 5-9, 2011; 01/2011
[show abstract][hide abstract] ABSTRACT: An increasing number of people are sharing ever-greater amounts of private information, making social networking sites a "personal data ecosystem". Such networks publish lengthy privacy policies explaining their data practices and provide users with extensive privacy controls to manage what they share and with whom. Despite this, privacy concerns over social networks are on the rise. It is not clear whether the published privacy policies are effectively reflected in privacy controls of the sites. In this paper we describe an exploratory approach that examines whether a clear mapping can be established between the privacy policies of social networking sites and the privacy controls. Our preliminary results show a significant disconnect between the two dichotomies.
PASSAT/SocialCom 2011, Privacy, Security, Risk and Trust (PASSAT), 2011 IEEE Third International Conference on and 2011 IEEE Third International Confernece on Social Computing (SocialCom), Boston, MA, USA, 9-11 Oct., 2011; 01/2011
[show abstract][hide abstract] ABSTRACT: Aspect developers constantly make a range of assumptions about the context in which their aspects will be deployed; ranging from assumptions about other aspects deployed to assumptions about semantic properties of the base and the joinpoints at which an aspect is woven. Although it has been acknowledged that such assumptions need to be made explicit to validate aspects in the face of evolution (both of aspects and the base) and reuse as well as to mitigate the fragile-pointcut problem, so far no study exists that identifies the types of assumptions aspect developers make. In this paper, we present a retrospective study of three medium-sized open-source AspectJ projects and assumptions identified in these. This leads to an initial classification of assumptions that can form the basis for further research into how best to support each type of assumption.
Proceedings of the 10th International Conference on Aspect-Oriented Software Development, AOSD 2011, Porto de Galinhas, Brazil, March 21-25, 2011; 01/2011
[show abstract][hide abstract] ABSTRACT: In order to improve SPL traceability by using design rationale, this chapter introduces the traceability analysis framework (TAF), which, when combined with the AMPLE Traceability Framework, provides extra traceability capabilities for variability management. The TAF is a programmable and extensible framework that aims to support the product line developers to understand the context, evolution and shortcomings in the design by means of the simulation of the design and the explanation of design rationale. Good expressiveness of the design rationale and the design issues is obtained by making the distinction between model-level semantics and method-level semantics clear and sepatately verifiable. Traceability is based on verifying both semantics, querying the design rationale and querying the model dependencies.
[show abstract][hide abstract] ABSTRACT: As aspects extend or replace existing functionality at specific join points in the code, their behavior may raise new exceptions, which can flow through the program execution in unexpected ways. Assuring the reliability of exception handling code in aspect-oriented (AO) systems is a challenging task. Testing the exception handling code is inherently difficult, since it is tricky to provoke all exceptions during tests, and the large number of different exceptions that can happen in a system may lead to the test-case explosion problem. Moreover, we have observed that some properties of AO programming (e.g., quantification, obliviousness) may conflict with characteristics of exception handling mechanisms, exacerbating existing problems (e.g., uncaught exceptions). The lack of verification approaches for exception handling code in AO systems stimulated the present work. This work presents a verification approach based on a static analysis tool, called SAFE, to check the reliability of exception handling code in AspectJ programs. We evaluated the effectiveness and feasibility of our approach in two complementary ways (i) by investigating if the SAFE tool is precise enough to uncover exception flow information and (ii) by applying the approach to three medium-sized ApectJ systems from different application domains.
[show abstract][hide abstract] ABSTRACT: The requirements and design level identification and representation of dynamic variability for adaptive systems is a challenging task. This requires time and effort to identify and model the relevant elements as well as the need to consider the large number of potentially possible system configurations. Typ- ically, each individual variability dimension needs to identified and modelled by enumerating each possible alternative. The full set of requirements needs to be reviewed to extract all potential variability dimensions. Moreover, each possible configuration of an adaptive system needs to be validated before use. In this demonstration, we present a tool suite that is able to manage dynamic variability in adaptive systems and tame such system complexity. This tool suite is able to automatically identify dynamic variability attributes such as variability dimensions, context, adaptation rules, and soft/hard goals from requirements documents. It also supports modelling of these artefacts as well as their run-time verification and validation. Index Terms—adaptive systems, feature models, natural lan- guage processing, modelling;
RE 2011, 19th IEEE International Requirements Engineering Conference, Trento, Italy, August 29 2011 - September 2, 2011; 01/2011
[show abstract][hide abstract] ABSTRACT: One of the main goals of Aspect-Oriented Requirements Engineering (AORE) is to address the composability and subsequent analysis of crosscutting requirements. How-ever, composing requirements in AORE may lead to con-flicting situations that have to be analyzed and resolved. There are a few AORE methods for resolving conflicts be-tween requirements, but most of them are error-prone or have scalability issues. This paper presents a mathemat-ical formulation for resolving conflicts that can be imple-mented with Search-based techniques (i.e., metaheuris-tics) to address the scalability and error-proneness of the existing AORE methods.
Information Sciences and Technologies Bulletin of the ACM Slovakia. 06/2010; 2(1):56-59.
[show abstract][hide abstract] ABSTRACT: Aspect-oriented software development techniques provide a means to modularize crosscutting concerns in software systems. A survey of industrial projects reveals the benefits and potential pitfalls of aspectoriented technologies.The past decade has seen the increased use of aspect-oriented software development (AOSD) technique as a means to modularize crosscutting concerns in software systems, thereby improving a development organization's working practices and return on investment (ROI). Numerous industrial-strength aspect-oriented (AO) programming frameworks exist, including AspectJ, JBoss, and Spring, as do various aspect-oriented analysis and design techniques.The software systems using AOSD that we have studied are medium to large-scale and span a wide range of domains including enterprise systems, e-health, e-transport, telecommunications, Web based information systems, multimedia applications, and workflow systems. Our analysis highlights typical usage patterns of AO techniques-for instance, they are mainly used for modularizing well-known crosscutting problems and incrementally introduced, addressing developmental concerns and other noncore product features first.
[show abstract][hide abstract] ABSTRACT: Software product lines using feature models often require the relation between feature models in problem space and the models
used to describe the details of the product line to be expressed explicitly. This is particularly important, where automatic
product derivation is required. Different approaches for modelling this mapping have been proposed in the literature. However,
a discussion of their relative benefits and drawbacks is currently missing. As a first step towards a better understanding
of this field, this paper applies two of these approaches—FeatureMapper as a representative of declarative approaches and
VML* as a representative of operational approaches—to the case study. We show in detail how the case study can be expressed
using these approaches and discuss strengths and weaknesses of the two approaches with regard to the case study.
T. Aspect-Oriented Software Development. 01/2010; 7:69-114.
[show abstract][hide abstract] ABSTRACT: Domain-specific languages are constructed to provide modelling capabilities tailored to a specific domain. Sometimes, languages
are developed many times, typically to support application in a new context. In doing so, recurring patterns and commonalities
as well as variations across the evolving set of languages can be identified. This paper introduces the concept of a domain-specific metamodelling language, which codifies such commonalities and provides concepts and logic for expressing the variations. The challenges and difficulties
of using domain-specific metamodelling languages are identified. We illustrate the concept with examples from different domains.
Software Language Engineering, Second International Conference, SLE 2009, Denver, CO, USA, October 5-6, 2009, Revised Selected Papers; 01/2009
[show abstract][hide abstract] ABSTRACT: The lack of architecturally-significant mechanisms for aspec- tual composition might artificially hinder the specification of stable and reusable design aspects. Current aspect-oriented approaches at the architecture-level tend to mimic program- ming language join point models while overlooking main- stream architectural concepts such as styles and their se- mantics. Syntax-based pointcuts are typically used to select join points based on the names of architectural elements, exposing architecture descriptions to pointcut fragility and reusability problems. This paper presents style-based com- position, a new flavor of aspect composition at the architec- tural level based on architectural styles. We propose style- based join point models and provide a pointcut language that supports the selection of join points based on style- constrained architectural models. Stability and reusability assessments of the proposed style-based composition model were carried out through three case studies involving differ- ent styles. The interplay of style-based pointcuts and some style composition techniques is also discussed.
Proceedings of the 8th International Conference on Aspect-Oriented Software Development, AOSD 2009, Charlottesville, Virginia, USA, March 2-6, 2009; 01/2009
[show abstract][hide abstract] ABSTRACT: Most current aspect composition mechanisms rely on syntactic references to the base modules or wildcard mechanisms quantifying over such syntactic references in pointcut expressions. This leads to the well-known problem of pointcut fragility. Semantics-based composition mechanisms aim to alleviate such fragility by focusing on the meaning and intention of the composition hence avoiding strong syntactic dependencies on the base modules. However, to date, there are no empirical studies validating whether semantics based composition mechanisms are indeed more expressive and less fragile compared to their syntax-based counterparts. In this paper we present a first study comparing semantics- and syntax-based composition mechanisms in aspect-oriented requirements engineering (AORE). In our empirical study the semantics-based compositions examined were found to be indeed more expressive and less fragile. The semantics-based compositions in the study also required one to reason about composition interdependencies early on hence potentially reducing the overhead of revisions arising from later trade-off analysis and stakeholder negotiations. However, this added to the overhead of specifying the compositions themselves. Furthermore, since the semantics-based compositions considered in the study were based on natural language analysis, they required initial effort investment into lexicon building as well as strongly depended on advanced tool support to expose the natural language semantics.
Proceedings of the 8th International Conference on Aspect-Oriented Software Development, AOSD 2009, Charlottesville, Virginia, USA, March 2-6, 2009; 01/2009