1,475 research outputs found
Early aspects: aspect-oriented requirements engineering and architecture design
This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications
A graph-based aspect interference detection approach for UML-based aspect-oriented models
Aspect Oriented Modeling (AOM) techniques facilitate separate modeling of concerns and allow for a more flexible composition of these than traditional modeling technique. While this improves the understandability of each submodel, in order to reason about the behavior of the composed system and to detect conflicts among submodels, automated tool support is required. Current techniques for conflict detection among aspects generally have at least one of the following weaknesses. They require to manually model the abstract semantics for each system; or they derive the system semantics from code assuming one specific aspect-oriented language. Defining an extra semantics model for verification bears the risk of inconsistencies between the actual and the verified design; verifying only at implementation level hinders fixng errors in earlier phases. We propose a technique for fully automatic detection of conflicts between aspects at the model level; more specifically, our approach works on UML models with an extension for modeling pointcuts and advice. As back-end we use a graph-based model checker, for which we have defined an operational semantics of UML diagrams, pointcuts and advice. In order to simulate the system, we automatically derive a graph model from the diagrams. The result is another graph, which represents all possible program executions, and which can be verified against a declarative specification of invariants.\ud
To demonstrate our approach, we discuss a UML-based AOM model of the "Crisis Management System" and a possible design and evolution scenario. The complexity of the system makes con°icts among composed aspects hard to detect: already in the case of two simulated aspects, the state space contains 623 di®erent states and 9 different execution paths. Nevertheless, in case the right pruning methods are used, the state-space only grows linearly with the number of aspects; therefore, the automatic analysis scales
Mixing of Join Point Interfaces and Feature-Oriented Programming for Modular Software Product Line
Feature-oriented programming (FOP) and aspect-oriented
programming (AOP) focus on to modularize incremental
classes behavior and crosscutting concerns, respectively, for
software evolution. So, these software development approaches
represent advanced paradigms for a modular software product
lines production. Thereby, a FOP and AOP symbiosis
would permit reaching pros and cons of both approaches.
FOP permits a modular re nement of classes collaboration for
software product lines (SPL), an adequate approach to
represent named heterogeneous crosscutting concerns. FOP
works on changes of di erent functionality pieces for which to
de ne join points is not a simple task. Similarly, AOP
structurally modularizes in a re ned manner homogeneous
crosscutting concerns. Since traditional AOP like AspectJ
presents implicit dependencies and strong coupling between
classes and aspects, and the Join Point Interface JPI ap-proach
solves these classic AOP issues, this article presents JPI
Feature Modules for the FOP + JPI SPL components
modularization, i.e., collaboration of classes, aspects, and join
point interfaces along with their evolution, for a SPL
transparent implementation in a FOP + JPI context. In
addition, this article shows JPI Feature Modules of a case study
to highlight mutual bene ts of FOP and JPI approaches for a
modular SPL software conception
JPI Feature Models: Exploring a JPI and FOP Symbiosis for Software Modeling
Looking for a complete modular software
development paradigm, this article presents Join Point Interface
JPI Feature Models, in the context of a JPI and Feature-Oriented
Programming FOP symbiosis paradigm. Therefore, this article
describes pros and cons of JPI and FOP approaches for the
modular software and software product line production,
respective; and highlights the benefits of this mixing proposal; in
particular, the JPI Feature Model benefits for a high-level
software product line modeling. As an application example, this
article applies JPI Features Models on a classic FOP example
already modeled using a previous aspect-oriented feature model
proposal. Main goals of this application are to visualize
traditional feature models preserved components such
alternative and optional feature sets and optional and mandatory
features as well as special features associations (cross-tree
constraints), and differences and advantages with respect to
previous research works about extending feature model to
support aspect-oriented modeling principles
A notational Design of Join Points
Join points are the composition points where aspects are composed with the base system. In other words they are target hooks in the base system where aspect’s implementation is weaved in. Join points are not defined separately in aspect-oriented design rather a pointcut model is designed which consists of related join points. Grouping of related join points in a pointcut depends on designer’s intuition and corresponding aspect’s nature which makes some of the join points overlooked or not properly grouped with the related join points. This paper proposes a solution to this problem by providing design notations for representing join points in design. This kind of design of join points help
designers design join points properly and group the related join points in one pointcut
Architecting Secure Software Systems Using an Aspect-Oriented Approach: : A Survey of Current Research
The importance of security in the development of complex software systems has increasingly become more critical as software becomes increasingly more pervasive in our everyday lives. Aspect-orientation has been proposed as a means to handle the crosscutting nature of security requirements when developing, designing and implementing security-critical applications. This paper surveys some of the approaches and contributions of integrating an aspect-oriented approach into designing and implementing secure software systems
Recommended from our members
Towards an aspect weaving BPEL engine
This position paper proposes the use of dynamic aspects and
the visitor design pattern to obtain a highly configurable and
extensible BPEL engine. Using these two techniques, the
core of this infrastructural software can be customised to
meet new requirements and add features such as debugging,
execution monitoring, or changing to another Web Service
selection policy. Additionally, it can easily be extended to
cope with customer-specific BPEL extensions. We propose
the use of dynamic aspects not only on the engine itself
but also on the workflow in order to tackle the problems of
Web Service hot deployment and hot fixes to long running
processes. In this way, composing aWeb Service "on-the-fly"
means weaving its choreography interface into the workflow
Aspect-Oriented Programming
Aspect-oriented programming is a promising idea that can improve the quality of software by reduce the problem of code tangling and improving the separation of concerns. At ECOOP'97, the first AOP workshop brought together a number of researchers interested in aspect-orientation. At ECOOP'98, during the second AOP workshop the participants reported on progress in some research topics and raised more issues that were further discussed. \ud
\ud
This year, the ideas and concepts of AOP have been spread and adopted more widely, and, accordingly, the workshop received many submissions covering areas from design and application of aspects to design and implementation of aspect languages
- …