Abstract. An architectural aspect is a concern that cuts across architecture modularity units and cannot be effectively modularized using the given abstractions of conventional Architecture Description Languages (ADLs). Dealing with crosscutting concerns is not a trivial task since they affect each other and the base architectural decomposition in multiple heterogeneous ways. The lack of ADL support for modularly representing such aspectual heterogeneous influences leads to a number of architectural breakdowns, such as increased maintenance overhead, reduced reuse capability, and architectural erosion over the lifetime of a system. On the other hand, software architects should not be burdened with a plethora of new ADL abstractions directly derived from aspect-oriented implementation techniques. However, most aspect-oriented ADLs rely on a heavyweight approach that mirrors programming languages concepts at the architectural level. In addition, they do not naturally support heterogeneous architectural aspects and proper resolution of aspect interactions. This paper presents AspectualACME, a simple and seamless extension of the ACME ADL to support the modular representation of architectural aspects and their multiple composition forms. AspectualACME promotes a natural blending of aspects and architectural abstractions by employing a special kind of architectural connector, called Aspectual Connector, to encapsulate aspect-component connection details. We have evaluated the applicability and scalability of the AspectualACME features in the context of three case studies from different application domains.

Inspired by our past manual aspect mining experiences, this paper describes a random walk model to approximate how crosscutting concerns can be discovered in the absence of domain knowledge of the investigated application. Random walks are performed on the coupling graphs extracted from the program sources. The ideas underlying the popular page-rank algorithm are adapted and extended to generate ranks reflecting the degrees of “popularity ” and “significance ” for each of the program elements on the coupling graphs. Filtering techniques, exploiting both types of ranks, are applied to produce a final list of candidates representing crosscutting concerns. The resulting aspect mining algorithm is evaluated on numerous Java applications ranging from a small-scale drawing application, to a medium-sized middleware application, and to a largescale enterprise application server. In seconds, the aspect mining algorithm is able to produce results comparable to our prior manual mining efforts. The mining algorithm also proves effective in helping domain experts identify latent crosscutting concerns.

The milestones of the history of software development are paradigm shifts. Each paradigm brought its own features and new ways of composing them to assemble software systems. Understanding the impact of paradigm shifts encompasses making comparisons among systems built with different paradigms. Performing this kind of assessments is a very difficult exercise since the characterization of software assets is generally performed using paradigm-specific quantifications. In this paper we propose a metamodel for describing software products (either source code or design models) that is paradigm-independent. This metamodel, combined with a formal quantification approach, can help performing paradigm-independent software systems assessment. We illustrate the use of the proposed metamodel on a case study comparing functionally-equivalent systems produced with OOP and AOP. 1.

Pointcut fragility is a well-documented problem in Aspect-Oriented Programming; changes to the base-code can lead to join points incorrectly falling in or out of the scope of pointcuts. In this paper, we present an automated approach which limits fragility problems by providing mechanical assistance in pointcut maintenance. The approach is based on harnessing arbitrarily deep structural commonalities between program elements corresponding to join points selected by a pointcut. The extracted patterns are then applied to later versions to offer suggestions of new join points that may require inclusion. To illustrate that the motivation behind our proposal is well-founded, we first empirically establish that join points captured by a single pointcut typically portray a significant amount of unique structural commonality by analyzing patterns extracted from 23 AspectJ programs. Then, we demonstrate the usefulness of our technique by rejuvenating pointcuts in multiple versions of 3 of these programs. The results show that our parameterized heuristic algorithm was able to automatically infer new join points in subsequent versions with an average recall of 0.93. Moreover, these join points appeared, on average, in the top 4 th percentile of the suggestions, indicating that the results were precise.

Designing a software architecture is about defining and composing highlevel design structures. Whereas describing several structures is is fairly well supported, both non-aspect-oriented and aspectoriented Architectural Description Languages (ADLs) fall short when it comes to documenting relations or compositions between architecturallyrelevant crosscutting structures. This makes in turn separation of important concerns in the architecture hard, thereby increasing maintenance overhead and reducing reuse capabilities. This paper identifies and analyzes examples of crosscutting structures in an architecture for an industrial Automatic Guided Vehicle Transportation System (AGVTS). This analysis allowed us to determine and introduce an initial set of structural composition operators into xADL, namely substructure, mapping, and unification. The operators ’ feasibility have been assessed while refactoring the existing AGVTS architecture. Based on a real maintenance scenario, we also investigate to what extent these explicit compositions led (or not) to enhanced architectural changeability for evolving the distribution strategy.

Abstract not found

Available online at www.sciencedirect.com

Abstract not found

Background: Aspect-oriented programming (AOP) is an emerging programming paradigm whose focus is about improving modularity, with an emphasis on the modularization of crosscutting concerns. Objective: The goal of this paper is to assess the extent to which an AOP language – ObjectTeams/Java (OT/J) – improves the modularity of a software system. This improvement has been claimed but, to the best of our knowledge, this paper is the first attempting to present quantitative evidence of it. Method: We compare functionally-equivalent implementations of the Gang-of-Four design patterns, developed in Java and OT/J, using software metrics. Results: The results of our comparison support the modularity improvement claims made in the literature. For six of the seven metrics used, the OT/J versions of the patterns obtained significantly better results. Limitations: This work uses a set of metrics originally defined for object-oriented (OO) systems. It may be the case that the metrics are biased, in that they were created in the context of OO programming (OOP), before the advent of AOP. We consider this comparison a stepping stone as, ultimately, we plan to assess the modularity improvements with paradigm independent metrics, which will conceivably eliminate the bias. Each individual example from the sample used in this paper is small. In future, we plan to replicate this experiment using larger systems, where the benefits of AOP may be more noticeable. Conclusion: This work contributes with evidence to fill gaps in the body of quantitative results supporting alleged benefits to software modularity brought by AOP languages, namely OT/J.

Abstract: A multi-agent system product line (MAS-PL) defines an architecture whose design and implementation is accomplished using software agents to address its common and variable features. MAS-PL promotes the large-scale reuse of common and variable agency features across multiple MAS applications. The development of MAS-PLs can be achieved through MAS-specific platforms and implementation techniques, such as conditional compilation and aspect-oriented programming (AOP). However, there is not much evidence on how these techniques provide better modularity, allowing the conception of stable MAS-PL designs. This paper presents a quantitative study on the design modularity and stability of an evolving MAS-PL. The MAS-PL was built following the reactive product line adoption approach. The product line was developed and evolved based on several versions of a conference management webbased system, named Expert Committee (EC). Our evaluation is made through a series of change scenarios related to new agency features, which are agent characteristics that enhance the system with autonomous behavior. The quantitative study consists of a systematic comparison between two different versions of the EC MAS-PL based on a MAS-specific platform, called JADE. One version was implemented with object-oriented and conditional