12 research outputs found
Addressing aspect interactions in an industrial setting: experiences, problems and solutions
Aspect oriented programming (AOP) introduces new and powerful modularization constructs. The aspect module is used to encapsulate crosscutting concerns, which otherwise would remain tangled and scattered. The idea of encapsulating crosscutting concerns rapidly expanded to earlier phases in the development cycle, including requirement analysis (aspect oriented requirement engineering, AORE) and design (aspect oriented modeling, AOM). The overall application of aspect orientation concepts is known as aspect oriented software development (AOSD). AOP is not yet a mainstream practice. Particularly AOSD is still in its early stages. This is reflected in the lack of reports of full development cycles using aspect oriented approaches, especially using industrial case studies. Furthermore, the power of aspects comes at the price of new challenges, one of them is that systems built using aspects are more difficult to understand. The crosscutting nature of aspects allows them to alter the behavior of many other modules. As a result, aspects may interact in unintended and unanticipated ways. This problem is known as aspect interactions. In this work we deal with the aspect interaction problem in the context of an industrial domain: slots machines. We perform a complete development cycle of the slot machine software. This is, to the best of our knowledge, the first complete industrial case of study of aspect orientation. Through this experience we discovered the limitations with regard to aspect interactions, of some emblematic aspect oriented approaches for requirement engineering, design and implementation. The contribution of this work is threefold. Firstly, we contribute with the evaluation and extensions to some of AORE and AOM approaches, in order to provide explicit support for aspect interactions in requirement analysis and design phases. We also evaluate the implementation of interactions using a static and a dynamic AOP language, and propose an AspectJ extension that copes with aspect interactions. Secondly, this work is the first report of a complete aspect oriented development cycle of an industrial case study. Thirdly, this work provides a complex case study that presents several business logic crosscutting concerns, which in turn exhibit numerous aspect interactions, that serves as a challenging test bed for upcoming AOSD approaches.Facultad de Informátic
Reverse Engineering Aspects to Derive Application Class Models
Aspects provide a nice way to modify behavior and implement cross-cutting concerns in object-oriented systems. As such, aspects do not have an existence of their own the application classes that the aspects refer to must be present in order to instantiate the aspects. In this research, we present a reverse engineering approach to generate a minimal class model that has all the structural elements necessary in order to complete exercise a set of aspect
Reverse Engineering Aspects to Derive Application Class Models
Aspects provide a nice way to modify behavior and implement cross-cutting concerns in object-oriented systems. As such, aspects do not have an existence of their own the application classes that the aspects refer to must be present in order to instantiate the aspects. In this research, we present a reverse engineering approach to generate a minimal class model that has all the structural elements necessary in order to complete exercise a set of aspect
Unweaving the Impact of Aspect Changes in AspectJ
Aspect-oriented programming (AOP) fosters the coding of tangled concerns in separated units that are then woven together in the executable system. Unfortunately, the oblivious nature of the weaving process makes difficult to figure out the augmented system behavior. It is difficult, for example, to understand the effect of a change just by reading the source code. In this paper, we focus on detecting the run time impact of the editing actions on a given set of test cases. Our approach considers two versions of an AspectJ program and a test case. Our tool, implemented on top of the abc weaver and the AJANA framework is able to map semantics changes to the atomic editing changes in the source code. Copyright 2009 ACM
Aspect Model Unweaving
International audienceSince software systems need to be continuously available, their ability to evolve at runtime is a key issue. The emergence of models@runtime, combined with Aspect-Oriented Modeling techniques, is a promising approach to tame the complexity of adaptive systems. However, with no support for aspect unweaving, these approaches are not agile enough in an adaptive system context. In case of small modifications, the adapted model has to be generated by again weaving all the aspects, even those unchanged. This paper shows how aspects can be unwoven, based on a precise traceability metamodel dedicated to aspect model weaving. We analyze traceability models, which describe how aspects were woven into a base, to determine the extent to which an aspect has affected the woven model in order to determine how it can be unwoven. Aspect unweaving is finally performed by applying inverse operations of a sub-sequence of the weaving operations in opposite order
StarMX: A Framework for Developing Self-Managing Software Systems
The scale of computing systems has extensively grown over the past few decades in order to satisfy emerging business requirements. As a result of this evolution, the complexity of these systems has increased significantly, which has led to many difficulties in managing and administering them. The solution to this problem is to build systems that are capable of managing themselves, given high-level objectives. This vision is also known as Autonomic Computing.
A self-managing system is governed by a closed control loop, which is responsible for dynamically monitoring the underlying system, analyzing the observed situation, planning the recovering actions, and executing the plan to maintain the system equilibrium. The realization of such systems poses several developmental and operational challenges, including: developing their architecture, constructing the control loop, and creating services that enable dynamic adaptation behavior. Software frameworks are effective in addressing these challenges: they can simplify the development of such systems by reducing design and implementation efforts, and they provide runtime services for supporting self-managing behavior.
This dissertation presents a novel software framework, called StarMX, for developing adaptive and self-managing Java-based systems. It is a generic configurable framework based on standards and well-established principles, and provides the required features and facilities for the development of such systems. It extensively supports Java Management Extensions (JMX) and is capable of integrating with different policy engines. This allows the developer to incorporate and use these techniques in the design of a control loop in a flexible manner. The control loop is created as a chain of entities, called processes, such that each process represents one or more functions of the loop (monitoring, analyzing, planning, and executing). A process is implemented by either a policy language or the Java language. At runtime, the framework invokes the chain of processes in the control loop, providing each one with the required set of objects for monitoring and effecting.
An open source Java-based Voice over IP system, called CC2, is selected as the case study used in a set of experiments that aim to capture a solid understanding of the framework suitability for developing adaptive systems and to improve its feature set. The experiments are also used to evaluate the performance overhead incurred by the framework at runtime. The performance analysis results show the execution time spent in different components, including the framework itself, the policy engine, and the sensors/effectors. The results also reveal that the time spent in the framework is negligible, and it has no considerable impact on the system's overall performance
Software Architecture Evolution
This chapter provides an overview, comparison and detailed treatment of the various state-of-the-art approaches to evolving software architectures. Furthermore, we discuss one particular framework for software architecture evolution in more detail
Advancing Operating Systems via Aspect-Oriented Programming
Operating system kernels are among the most complex pieces of software in existence to-
day. Maintaining the kernel code and developing new functionality is increasingly compli-
cated, since the amount of required features has risen significantly, leading to side ef fects
that can be introduced inadvertedly by changing a piece of code that belongs to a completely
dif ferent context.
Software developers try to modularize their code base into separate functional units.
Some of the functionality or “concerns” required in a kernel, however, does not fit into
the given modularization structure; this code may then be spread over the code base and
its implementation tangled with code implementing dif ferent concerns. These so-called
“crosscutting concerns” are especially dif ficult to handle since a change in a crosscutting
concern implies that all relevant locations spread throughout the code base have to be
modified.
Aspect-Oriented Software Development (AOSD) is an approach to handle crosscutting
concerns by factoring them out into separate modules. The “advice” code contained in
these modules is woven into the original code base according to a pointcut description, a
set of interaction points (joinpoints) with the code base.
To be used in operating systems, AOSD requires tool support for the prevalent procedu-
ral programming style as well as support for weaving aspects. Many interactions in kernel
code are dynamic, so in order to implement non-static behavior and improve performance,
a dynamic weaver that deploys and undeploys aspects at system runtime is required.
This thesis presents an extension of the “C” programming language to support AOSD.
Based on this, two dynamic weaving toolkits – TOSKANA and TOSKANA-VM – are presented
to permit dynamic aspect weaving in the monolithic NetBSD kernel as well as in a virtual-
machine and microkernel-based Linux kernel running on top of L4. Based on TOSKANA,
applications for this dynamic aspect technology are discussed and evaluated.
The thesis closes with a view on an aspect-oriented kernel structure that maintains
coherency and handles crosscutting concerns using dynamic aspects while enhancing de-
velopment methods through the use of domain-specific programming languages