Atef Bader

Designing an aspect-oriented framework in an object-oriented environment

Separation of concerns is at the heart of software development, and although its benefits have been well established, the core problem remains how to achieve it. For complex software systems the solution is still debatable and it is a major research area. Object Oriented Programming (OOP) works well only if the problem at hand can be described with relatively simple interface among objects. Unfortunately, this is not the case when we move from sequential programming to concurrent and distributed programming. The September 1993 CACM issue was devoted to the problematic marriage between OOP and Concurrency [Cohen 93]. Since then, numerous workshops, articles and books have attempt to tackle the problem. The core complexity is that concurrent and distributed systems manifest over more than one dimension. Features such as scheduling, synchronization, fault tolerance, security, testing and verifications are all expressed in such a way that they tend to cut across different objects. Hence, simple object interfaces are violated and the traditional OOP benefits no longer hold. One of the current attempts to resolve this issue is the Aspect Oriented Software Architecture. To address this multi-dimensional structure of concurrent systems we distinguish between components and aspects. Aspects are defined as properties of a system that do not necessarily align with the systems functional components but tend to cut across functional components, increasing their interdependencies, and thus affecting the quality of the software. Although not bound to OOP, Aspect-Oriented Programming (AOP) is a paradigm proposal that retains the advantages of OOP and aims at achieving a better separation of concerns. In this paper we provide an assessment of AOP and we discuss the architecture of an aspectoriented framework. The goals of our proposal is to achieve an improved separation of concerns in both design, and implementation, to provide adaptability, and to support the complex interaction among non-orthogonal aspects. 1. The “Code Tangling” Problem The traditional approach for organizing software systems has been based on some form of functional decomposition. A problem is broken down into sub-problems that can be addressed relatively independently. Current programming languages and paradigms support implementation, ___________________ Permission to make digital/hard copy of part or all of this work for personal or classroom use is granted without fee provided that the copies are not made or distributed for profit or commercial advantage, the copyright notice, the title of the publication, and its data appear, and notice is given that copying is by permission of the ACM, Inc. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee.

The Adaptive Arena: language constructs and architectural abstractions for concurrent object-oriented systems

In this paper we present a concurrent object-oriented model in which a concurrent object, which represents a shared resource abstraction in our model, is decomposed into a hierarchy of architectural abstractions: a shared data abstraction, a synchronization abstraction, and a scheduling abstraction. It will be shown that the separation of concerns among the three major components of the concurrent objects avoids many of the conceptual difficulties that arise when integrating concurrency into the object-oriented paradigm. The proposed model presents a formal methodology for the architectural design and specification of the concurrent object-oriented software systems. The notion of scheduling policy inheritance in our model facilitates the process of engineering adaptability in the development of the intelligent reactive/adaptive systems.

Aspect interaction chart - a UML approach for modularizing aspect interaction conflicts

Crosscutting concerns exist well before the implementation phase of software development life cycle (SDLC). Aspects modularize these crosscutting concerns. However, introduction of aspects within a system may bring along issues related to unanticipated aspect interactions. The scattered nature of these interactions causes unpredictable and sometimes harmful system behavior. In order to identify and manipulate these interactions, the system designer needs to inspect and analyze the interactions with respect to control and state dependencies between the various aspects and core functionality. Current approaches to study aspect interactions present the aspect interaction analysis results in one monolithic composed model. This makes it hard for the system architect to study and refine these interactions. In this paper we present a unique approach to modularly capture aspect interaction conflicts at multiple levels of granularity during the requirements and design phases of software development. The proposed approach, Aspect Interaction Charts (AIC), is a UML profile extension to the interaction overview diagram. The AIC automatically captures control-flow and state dependencies between conflicting and dependent aspect scenarios, thereby documenting potentially undetected harmful aspect interactions at many possible levels of granularity, which is a unique characteristic of this approach.

Adaptability vs. reusability of software systems

Every software system changes over its lifetime. Some of the changes are predictable, and systems can be designed to be robust to such changes by considering those future changes beforehand. However, it is impossible to predict all the future changes and possible concerns. Anticipating the various concerns is hard due to the diversity in client requirements and the rapid advances in the enabling technologies. Because unanticipated changes often require many parts of the system to be modified or redesigned, they are very costly most of the time. Therefore, it is necessary to engineer adaptability into software systems in order to meet various future requirements. Adaptability is the cornerstone of a successful design. In this paper we present an application framework, the Aspect Moderator Framework (AMF), which can make a software system adaptable and robust to changes over its lifetime, thus reducing overall system cost. This paper shows how the Aspect Moderator Framework (AMF) can be used to build commercial applications that can evolve and adapt to new requirements easily.