|
|
Modularizing design patterns with aspects: a quantitative study |
| |
Alessandro Garcia,
Cláudio Sant'Anna,
Eduardo Figueiredo,
Uirá Kulesza,
Carlos Lucena,
Arndt von Staa
|
|
Pages: 3-14 |
|
doi>10.1145/1052898.1052899 |
|
Full text:  PDF
|
|
Design patterns offer flexible solutions to common problems in software development. Recent studies have shown that several design patterns involve crosscutting concerns. Unfortunately, object-oriented (OO) abstractions are often not able to modularize ...
Design patterns offer flexible solutions to common problems in software development. Recent studies have shown that several design patterns involve crosscutting concerns. Unfortunately, object-oriented (OO) abstractions are often not able to modularize those crosscutting concerns, which in turn decrease the system reusability and maintainability. Hence, it is important verifying whether aspect-oriented approaches support improved modularization of crosscutting concerns relative to design patterns. Ideally, quantitative studies should be performed to compare OO and aspect-oriented implementations of classical patterns with respect to important software engineering attributes, such as coupling and cohesion. This paper presents a quantitative study that compares aspect-based and OO solutions for the 23 Gang-of-Four patterns. We have used stringent software engineering attributes as the assessment criteria. We have found that most aspect-oriented solutions improve separation of pattern-related concerns, although only 4 aspect-oriented implementations have exhibited significant reuse. expand
|
|
|
An analysis of modularity in aspect oriented design |
| |
Cristina Videira Lopes,
Sushil Krishna Bajracharya
|
|
Pages: 15-26 |
|
doi>10.1145/1052898.1052900 |
|
Full text: PDF
|
|
We present an analysis of modularity in aspect oriented design using the theory of modular design developed by Baldwin and Clark [10]. We use the three major elements of that theory, namely: i) Design Structure Matrix (DSM), an analysis and modeling ...
We present an analysis of modularity in aspect oriented design using the theory of modular design developed by Baldwin and Clark [10]. We use the three major elements of that theory, namely: i) Design Structure Matrix (DSM), an analysis and modeling tool; ii) Modular Operators, units of variations for design evolution; and iii) Net Options Value (NOV), a quantitative approach to evaluate design. We study the design evolution of a Web Services application where we observe the effects of applying aspect oriented modularization.Based on our analysis we get to the following three main conclusions. First, on the structural part, it is possible to apply the DSM to aspect oriented modularizations in a straightforward manner, i.e. without modifications to DSMs basic model. This shows that aspects can, in fact, be treated as modules of design. Second, the evolution of a design into including aspect modules uses the modular operators proposed by Baldwin and Clark, with a variant of the Inversion operator. This variant captures taking redundant, scattered information hidden in modules and moving it down or keeping it at the same level in the design hierarchy. Third, when calculating and comparing NOVs of the different designs of our application, we obtained higher NOV for the design with aspects than for the design without aspects. This shows that, under this theory of modularity, certain aspect oriented modularizations can add value to the design. expand
|
|
|
An expressive aspect language for system applications with Arachne |
| |
Rémi Douence,
Thomas Fritz,
Nicolas Loriant,
Jean-Marc Menaud,
Marc Ségura-Devillechaise,
Mario Südholt
|
|
Pages: 27-38 |
|
doi>10.1145/1052898.1052901 |
|
Full text: PDF
|
|
C applications, in particular those using operating system level services, frequently comprise multiple crosscutting concerns: network protocols and security are typical examples of such concerns. While these concerns can partially be addressed during ...
C applications, in particular those using operating system level services, frequently comprise multiple crosscutting concerns: network protocols and security are typical examples of such concerns. While these concerns can partially be addressed during design and implementation of an application, they frequently become an issue at runtime, e.g., to avoid server downtime. A deployed network protocol might not be efficient enough and may thus need to be replaced. Buffer overflows might be discovered that imply critical breaches in the security model of an application. A prefetching strategy may be required to enhance performance.While aspect-oriented programming seems attractive in this context, none of the current aspect systems is expressive and efficient enough to address such concerns. This paper presents a new aspect system to provide a solution to this problem. While efficiency considerations have played an important part in the design of the aspect language, the language allows aspects to be expressed more concisely than previous approaches. In particular, it allows aspect programmers to quantify over sequences of execution points as well as over accesses through variable aliases. We show how the former can be used to modularize the replacement of network protocols and the latter to prevent buffer overflows. We also present an implementation of the language as an extension of Arachne, a dynamic weaver for C applications. Finally, we present performance evaluations supporting that Arachne is fast enough to extend high performance applications, such as the Squid web cache. expand
|
|
|
Empowering configurable QoS management in real-time systems |
| |
Aleksandra Tesanovic,
Mehdi Amirijoo,
Mikael Björk,
Jörgen Hansson
|
|
Pages: 39-50 |
|
doi>10.1145/1052898.1052902 |
|
Full text: PDF
|
|
Current Quality of Service (QoS) management methods in real-time systems using feedback control loop lack support for configurability and reusability as they cannot be configured for a target application or reused across different applications. In this ...
Current Quality of Service (QoS) management methods in real-time systems using feedback control loop lack support for configurability and reusability as they cannot be configured for a target application or reused across different applications. In this paper we present a method for developing reconfigurable feedback-based QoS management for real-time systems, denoted Re-QoS. By combining component-based design with aspect-oriented software development Re-QoS enables successful handling of crosscutting nature of QoS policies, as well as evolutionary design of real-time systems and QoS management architectures. Re-QoS defines a QoS aspect package, which is an implementation of a set of aspects and components that provide a number of different QoS policies. By adding a QoS aspect package to an existing system without QoS guarantees, we are able to use the same system in unpredictable environments where performance guarantees are essential. Furthermore, by exchanging aspects within the QoS aspect package one can efficiently tailor the QoS management of a real-time system based on the application requirements. We demonstrate the usefulness of the concept on a case study of an embedded real-time database system, called COMET. Using the COMET example we show how a real-time database system can be adapted to be used in different applications with distinct QoS needs. expand
|
|
|
Supporting autonomic computing functionality via dynamic operating system kernel aspects |
| |
Michael Engel,
Bernd Freisleben
|
|
Pages: 51-62 |
|
doi>10.1145/1052898.1052903 |
|
Full text: PDF
|
|
To master the complexity of software systems in the presence of unexpected events potentially affecting system operation, the Autonomic Computing Initiative [16] aims to build systems that have the ability to control and organize themselves to ...
To master the complexity of software systems in the presence of unexpected events potentially affecting system operation, the Autonomic Computing Initiative [16] aims to build systems that have the ability to control and organize themselves to meet unforeseen changes in the hard- and software environment.The basic principles employed by autonomic computing are self-configuration, self-optimization, self-healing and self-protection. Typically, these principles are cross-cutting concerns, so an obvious approach to their realization in software is to use aspect-oriented programming (AOP). Since autonomic systems have to adapt their behavior to changing runtime conditions, a dynamic AOP approach is required to implement autonomic computing functionality.This paper introduces the TOSKANA toolkit for deploying dynamic aspects into an operating system kernel as a central part of a computer system having an overview of current system operation and resource usage. TOSKANA provides before, after and around advice for in-kernel functions and supports the specification of pointcuts as well as the implementation of aspects themselves as dynamically exchangeable kernel modules. The use of TOSKANA is demonstrated by several examples indicating the cross-cutting nature of providing autonomic computing functionality in an operating system kernel. Performance results are presented to characterize the aspect deployment overhead incurred by using TOSKANA. expand
|
|
|
Towards just-in-time middleware architectures |
| |
Charles Zhang,
Dapeng Gao,
Hans-Arno Jacobsen
|
|
Pages: 63-74 |
|
doi>10.1145/1052898.1052904 |
|
Full text: PDF
|
|
Middleware becomes increasingly important in building distributed applications. Today, conventional middleware systems are designed, implemented, and packaged prior to their applications. We argue that with this middleware construction paradigm it is ...
Middleware becomes increasingly important in building distributed applications. Today, conventional middleware systems are designed, implemented, and packaged prior to their applications. We argue that with this middleware construction paradigm it is often difficult to meet the challenges imposed by application specific customization requirements. We propose to reverse this paradigm by automatically synthesizing middleware structures as the result of reasoning about the distribution needs of the user application of middleware. We term this type of post-postulated middleware Just-in-time middleware (JiM). In this paper, we present our initial design and present an evaluation of the JiM paradigm through Abacus, a CORBA middleware implementation based on the aspect oriented refactoring of an industrial strength object request broker. In addition, we present Arachne, the Abacus synthesizer, which integrates source analysis, feature inference, and implementation synthesis. Our evaluations show that, through automatic synthesis alone, Abacus is able to support diversified application domains with very flexible architectural compositions and versatile resource requirements as compared to conventional pre-postulated approaches. expand
|
|
|
Adaptive programming in JAsCo |
| |
Wim Vanderperren,
Davy Suvée,
Bart Verheecke,
María Agustina Cibrán,
Viviane Jonckers
|
|
Pages: 75-86 |
|
doi>10.1145/1052898.1052905 |
|
Full text: PDF
|
|
In this paper we propose an extension to JAsCo for supporting Adaptive Programming in a Component-Based Software Development context. JAsCo is an aspect-oriented programming language targeted at Component-Based Software Development and allows encapsulating ...
In this paper we propose an extension to JAsCo for supporting Adaptive Programming in a Component-Based Software Development context. JAsCo is an aspect-oriented programming language targeted at Component-Based Software Development and allows encapsulating crosscutting concerns using highly reusable aspect beans. Adaptive Programming on the other hand, allows capturing crosscutting concerns by structure-shy adaptive visitors. We propose to implement an adaptive visitor as a regular JAsCo aspect bean. Hence, the reusability of an adaptive visitor is improved because the same visitor can be reused within different component contexts. We introduce JAsCo traversal connectors to deploy adaptive visitors, implemented as JAsCo aspect beans, upon a concrete component traversal. In addition, these traversal connectors allow to explicitly specify how the behavior of several adaptive visitors, instantiated onto the same component traversal, needs to be combined by making use of the JAsCo precedence and combination strategies. A prototype implementation of the JAsCo Adaptive Programming extension, which employs the DJ library, is available. As a proof of concept, we present an extended case study in the context of the Web Service Management Layer (WSML) project. In this case study, a set of visitors implemented in JAsCo is reused to accomplish multiple tasks. expand
|
|
|
abc: an extensible AspectJ compiler |
| |
Pavel Avgustinov,
Aske Simon Christensen,
Laurie Hendren,
Sascha Kuzins,
Jennifer Lhoták,
Ondřej Lhoták,
Oege de Moor,
Damien Sereni,
Ganesh Sittampalam,
Julian Tibble
|
|
Pages: 87-98 |
|
doi>10.1145/1052898.1052906 |
|
Full text: PDF
|
|
Research in the design of aspect-oriented programming languages requires a workbench that facilitates easy experimentation with new language features and implementation techniques. In particular, new features for AspectJ have been proposed that require ...
Research in the design of aspect-oriented programming languages requires a workbench that facilitates easy experimentation with new language features and implementation techniques. In particular, new features for AspectJ have been proposed that require extensions in many dimensions: syntax, type checking and code generation, as well as data flow and control flow analyses.The AspectBench Compiler (abc) is an implementation of such a workbench. The base version of abc implements the full AspectJ language. Its frontend is built, using the Polyglot framework, as a modular extension of the Java language. The use of Polyglot gives flexibility of syntax and type checking. The backend is built using the Soot framework, to give modular code generation and analyses.In this paper, we outline the design of abc, focusing mostly on how the design supports extensibility. We then provide a general overview of how to use abc to implement an extension. Finally, we illustrate the extension mechanisms of abc through a number of small, but non-trivial, examples. abc is freely available under the GNU LGPL. expand
|
|
|
What does aspect-oriented programming mean to Cobol? |
| |
Ralf Lämmel,
Kris De Schutter
|
|
Pages: 99-110 |
|
doi>10.1145/1052898.1052907 |
|
Full text: PDF
|
|
We study AOP in the context of business programming with Cobol. We face the following questions: What are join points in Cobol programs? What is advice? Does classic Cobol provide any constructs that hint at AOP? (Yes!) What are typical crosscutting ...
We study AOP in the context of business programming with Cobol. We face the following questions: What are join points in Cobol programs? What is advice? Does classic Cobol provide any constructs that hint at AOP? (Yes!) What are typical crosscutting concerns in the Cobol world? How do otherwise typical crosscutting concerns make sense for Cobol? How does AOP for Cobol align with classic re-engineering transformations for Cobol? We deliver an AOP language design for Cobol. Codename: AspectCobol. While we adopt several ideas from AspectJ and friends, we also devise original techniques for joint-point identification and context capture. We briefly discuss a prototypical implementation of AspectCobol. expand
|
|
|
Towards a catalog of aspect-oriented refactorings |
| |
Miguel P. Monteiro,
João M. Fernandes
|
|
Pages: 111-122 |
|
doi>10.1145/1052898.1052908 |
|
Full text: PDF
|
|
In this paper, we present a collection of aspect-oriented refactorings covering both the extraction of aspects from object-oriented legacy code and the subsequent tidying up of the resulting aspects. In some cases, this tidying up entails the replacement ...
In this paper, we present a collection of aspect-oriented refactorings covering both the extraction of aspects from object-oriented legacy code and the subsequent tidying up of the resulting aspects. In some cases, this tidying up entails the replacement of the original implementation with a different, centralized design, made possible by modularization. The collection of refactorings includes the extraction of common code in various aspects into abstract superaspects. We review the traditional object-oriented code smells in the light of aspect-orientation and propose some new smells for the detection of crosscutting concerns. In addition, we propose a new code smell that is specific to aspects. expand
|
|
|
Deriving refactorings for AspectJ |
| |
Leonardo Cole,
Paulo Borba
|
|
Pages: 123-134 |
|
doi>10.1145/1052898.1052909 |
|
Full text: PDF
|
|
In this paper we present aspect-oriented programming laws that are useful for deriving refactorings for AspectJ. The laws help developers to verify if the transformations they define preserve behaviour. We illustrate that by deriving several AspectJ ...
In this paper we present aspect-oriented programming laws that are useful for deriving refactorings for AspectJ. The laws help developers to verify if the transformations they define preserve behaviour. We illustrate that by deriving several AspectJ refactorings. We also show that our laws are useful for restructuring two Java applications with the aim of using aspects to modularize common crosscutting concerns. expand
|
|
|
Role-based refactoring of crosscutting concerns |
| |
Jan Hannemann,
Gail C. Murphy,
Gregor Kiczales
|
|
Pages: 135-146 |
|
doi>10.1145/1052898.1052910 |
|
Full text: PDF
|
|
Improving the structure of code can help developers work with a software system more efficiently and more consistently. To aid developers in re-structuring the implementation of crosscutting concerns using aspect-oriented programming, we introduce a ...
Improving the structure of code can help developers work with a software system more efficiently and more consistently. To aid developers in re-structuring the implementation of crosscutting concerns using aspect-oriented programming, we introduce a role-based refactoring approach and tool. Crosscutting concerns (CCCs) are described in terms of abstract roles, and instructions for refactoring crosscutting concerns are written in terms of those roles. To apply a refactoring, a developer maps a subset of the roles to concrete program elements; a tool can then help complete the mapping of roles to the existing program. Refactoring instructors are then applied to manipulate and modularize the concrete elements corresponding to the crosscutting concern. Evaluation of the prototype tool on a graphical editing framework suggests that the approach helps planning and executing complex CCC refactorings. expand
|
|
|
Weaving a social fabric into existing software |
| |
Li-Te Cheng,
John Patterson,
Steven L. Rohall,
Susanne Hupfer,
Steven Ross
|
|
Pages: 147-158 |
|
doi>10.1145/1052898.1052911 |
|
Full text: PDF
|
|
Contextual collaboration is a promising approach to embedding new collaborative features into existing applications. However, incorporating such new features may be too difficult for applications without extensible frameworks or too complex for legacy, ...
Contextual collaboration is a promising approach to embedding new collaborative features into existing applications. However, incorporating such new features may be too difficult for applications without extensible frameworks or too complex for legacy, custom, and mission-critical applications. We present Aspect-Oriented Retrofitting as a lightweight approach to embedding contextual collaboration in this class of applications, describe guidelines for designing retrofitting aspects, and walk through two examples. expand
|
|
|
Mylar: a degree-of-interest model for IDEs |
| |
Mik Kersten,
Gail C. Murphy
|
|
Pages: 159-168 |
|
doi>10.1145/1052898.1052912 |
|
Full text: PDF
|
|
Even when working on a well-modularized software system, programmers tend to spend more time navigating the code than working with it. This phenomenon arises because it is impossible to modularize the code for all tasks that occur over the lifetime of ...
Even when working on a well-modularized software system, programmers tend to spend more time navigating the code than working with it. This phenomenon arises because it is impossible to modularize the code for all tasks that occur over the lifetime of a system. We describe the use of a degree-of-interest (DOI) model to capture the task context of program elements scattered across a code base. The Mylar tool that we built encodes the DOI of program elements by monitoring the programmer's activity, and displays the encoded DOI model in views of Java and AspectJ programs. We also present the results of a preliminary diary study in which professional programmers used Mylar for their daily work on enterprise-scale Java systems. expand
|
|
|
Crosscutting techniques in program specification and analysis |
| |
Patrick Lam,
Viktor Kuncak,
Martin Rinard
|
|
Pages: 169-180 |
|
doi>10.1145/1052898.1052913 |
|
Full text: PDF
|
|
We present three aspect-oriented constructs (formats, scopes, and defaults) that, in combination with a specification language based on abstract sets of objects, enable the modular application of multiple arbitrarily precise (and therefore ...
We present three aspect-oriented constructs (formats, scopes, and defaults) that, in combination with a specification language based on abstract sets of objects, enable the modular application of multiple arbitrarily precise (and therefore arbitrarily unscalable) analyses to scalably verify data structure consistency properties in sizable programs. Formats use a form of field introduction to group together the declarations of all of the fields that together comprise a given data structure. Scopes and defaults enable the developer to state certain data structure consistency properties once in a single specification construct that cuts across the preconditions and postconditions of the procedures in the system. Standard approaches, in contrast, scatter and duplicate such properties across the preconditions and postconditions. We have implemented a prototype implementation, specification, analysis, and verification system based on these constructs and used this system to successfully verify a range of data structure consistency properties in several programs.Most previous research in the field of aspect-oriented programming has focused on the use of aspect-oriented concepts in design and implementation. Our experience indicates that aspect-oriented concepts can also be extremely useful for specification, analysis, and verification. expand
|
|
|
Aspect language features for concern coverage profiling |
| |
Hridesh Rajan,
Kevin Sullivan
|
|
Pages: 181-191 |
|
doi>10.1145/1052898.1052914 |
|
Full text: PDF
|
|
In program profiling to assess test set adequacy, a challenge is to select code to be included in the assessment. Current mechanisms are coarse-grained; biased to dominant modularizations; require tedious, error-prone manual selection; and leave tester ...
In program profiling to assess test set adequacy, a challenge is to select code to be included in the assessment. Current mechanisms are coarse-grained; biased to dominant modularizations; require tedious, error-prone manual selection; and leave tester intent implicit in inputs to testing tools. Aspect-oriented constructs promise to improving testing in two ways: by improving our ability to select the code to include in adequacy criteria, and by documenting selection intentions in declarative form in the code itself. One problem is that current join point models do not reveal program behavior in enough detail to support white-box coverage analysis. Our contribution is the formulation, prototyping, and evaluation of a language-and-tool-based approach to white-box coverage adequacy analysis that we call concern coverage. We develop and evaluate one instance of the general idea in which branches, in particular, are exposed as join points to support branch coverage analysis of crosscutting concerns. Our results are consistent with the claim that the idea has the potential to improve test coverage analysis. expand
|
|
|
Distributing classes with woven concerns: an exploration of potential fault scenarios |
| |
Nathan McEachen,
Roger T. Alexander
|
|
Pages: 192-200 |
|
doi>10.1145/1052898.1052915 |
|
Full text: PDF
|
|
Aspect-oriented programming (AOP) promises to benefit software engineering by providing a layer of abstraction that can modularize system-level concerns. AOP is still a very young area of research and has yet to receive mainstream acceptance in industry. ...
Aspect-oriented programming (AOP) promises to benefit software engineering by providing a layer of abstraction that can modularize system-level concerns. AOP is still a very young area of research and has yet to receive mainstream acceptance in industry. As a result, the industry as a whole lacks experience and knowledge concerning long term maintenance issues with AOP in deployed commercial applications. Fault models that result from software maintenance in aspect-oriented software development (AOSD) are not nearly as well understood as they are for object-oriented software development (OOSD). This paper will explore some of the long-term maintenance issues that can occur with AspectJ, which is an implementation of AOP for the Java programming language. More specifically, the ability of AspectJ (as of version 1.2) to weave into existing bytecode that already contains woven aspects can create unexpected and potentially unsolvable problems. This will hopefully lead to further discussion in the research community that will result in a better understanding of the long-term maintenance issues inherent in AOSD. expand
|
Check out a preview of the 
Contact Us
|
Switch to tabbed view
ABSTRACT
semmle.com
previous proceeding