Constantinos Constantinides

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.

Extending the object model to provide explicit support for crosscutting concerns

Concurrent systems tend to have certain properties that are not localized in single modular units, but their implementations cut across functional components, increasing coupling and making modular units difficult to reuse and adapt. Example properties include concurrency, synchronization, and authentication. This problem is particularly apparent in systems with evolving requirements, as adapting code that is not localized in single modular units proves to be a tedious process. In this paper we discuss issues related to requirements of concurrent software systems to provide explicit support for these cross‐cutting concerns, and we present the Aspect Moderator, a framework extension to the object model that can ease the development of concurrent object‐oriented systems. Copyright

The development of generic definitions of hyperslice packages in Hyper/J

Abstract In this paper we investigate the notion of reusability of aspect definitions. We discuss the development of generic aspects in Hyper/J and compare it with the AspectJ approach. In doing that, we follow the design principle of “developing with hyperslice packages” and we show that hyperspace structure, concern mapping, hyperslice definitions and merging stategies exhibit well-defined patterns. An approach to constructing and merging generic aspects with base core concerns in Hyper/J is presented.

Aspect-oriented frameworks (poster session): the design of adaptable operating systems

With software systems such as operating systems, the interaction of their components becomes more complex. This interaction may limit reusability, adaptability, and make it difficult to validate the design and correctness of the system. As a result, re-engineering of these systems might be inevitable to meet future requirements. There is a general feeling that OOP promotes reuse and expandability by its very nature. This is a misconception as none of these issues is enforced. Rather, a software system must be specifically designed for reuse, expandability, and adaptability [4]. Operating systems are dominated in many aspects. Supporting separation of concerns and aspectual decomposition in the design of operating systems provides a number of benefits such as reusability, expandability, adaptability and reconfigurability. However, such support is difficult to accomplish. Aspect-Oriented Programming (AOP) [7] is a paradigm proposal that aims at separating components and aspects from the early stages of the software life cycle, and combines them together at the implementation phase. Besides, Aspect-Oriented Programming promotes the separation of the different aspects of components in the system into their natural form. However, Aspect-Oriented software engineering can be supported well if there is an operating system, which is built based on an aspect-oriented design. Therefore aspects can be created in applications, reused and adapted from the aspects provided by the operating systems. Object-Oriented Operating Systems treat aspects, components, and layers as a two dimensional models, which is not a good design model. Aspects in the operating system cannot be captured in the design and implementation. Two-dimensional models lead to inflexibility, limit possibilities for reuse and adaptability, and make it hard to understand and modify. The poster will show an Aspect-Oriented Framework [1, 8], which simplifies system design by expressing its design at a higher level of abstraction, for supporting the design of adaptable operating systems. A framework is more than a class hierarchy and it is a reusable to produce custom systems and applications [5]. Aspect-Oriented Framework is based on a three-dimensional design that consists of components, aspects, and layers. Components consist of the basic functionality modules of the system. Aspects are the properties in the systems that cut across the components in the operating systems. Some aspects in operating systems such as synchronization, scheduling, fault-tolerance cut across, in horizontal and vertical, the basic functionality of the systems. Layers consist of the components and aspects. By separating aspects and components of the operating systems in every layer, we can provide a better generic design model of the operating systems. The framework uses design patterns [6]. The overall architecture is divided into two frameworks: Base Layer and Application Layer Framework. The poster will show The UML model of frameworks and how to maximize separation of aspects, components, and layers from each other. Our goal is to achieve a better design model and implementation of operating systems, in terms of reusability, adaptability, extensibility, and reconfigurability.

Towards a two-dimensional separation of concerns (poster session)

As the size and requirements of software systems increase, their design has reached a complexity that requires software engineers to revisit the principle of separation of concerns [5]. Traditional software organization has been performed along some form of functional decomposition. Different paradigms and languages support the implementation, and composition of sub-parts into whole systems through the availability of some modular unit of functionality (component). In essence, traditional software decomposition and current programming languages have been mutually supportive [4]. At the same time, separation of concerns can only be beneficial if the different concerns can be effectively composed to produce the overall system. The OOP paradigm seems to work well only if the problem to be solved can be described with relatively simple interfaces among objects. Unfortunately, this is not the case when we move from sequential programming to concurrent programming where the component interaction violates simple object interfaces. One of the reasons behind this is the inherent structure of todays software systems that conceptually does not lead itself to a safe decomposition. As a result, the benefits associated with OOP no longer hold. Component interactions limit reuse and make it difficult to validate the design and correctness of software systems. Reengineering of these systems is needed in order to meet future changes in requirements. This component interaction is based on a number of properties that affect the semantics or the performance of the system and do not localize well in one modular unit, but tend to cut-across groups of components resulting in a “code tangling” [4]. Example cross-cutting properties (or aspects) include synchronization, scheduling, and fault tolerance. This code tangling destroys modularity, making the source code difficult to develop and difficult to understand. It also limits reuse, making the source code difficult to evolve. It further makes programs more error prone. In essence, it destroys the quality of the software. In [1] the authors refer to these phenomena as “composition anomalies”. This composition anomaly requires a shift in the methodologies used to separate concerns. In conjunction with modular composition, adaptability and reuse remain major issues to be considered while building complex software systems. Aspect-Oriented Programming (AOP) [4] is an emerging methodology that addresses components and aspects at the analysis and design phase of the software life-cycle, using mechanisms to compose them at the implementation level with a growing number of different technologies.

A Two-Dimensional Composition Framework to Support Software Adaptability and Reuse

As software systems become larger, the interaction of their components becomes more complex. This interaction may limit reuse, and make it difficult to validate the design and correctness of the system. As a result, re-engineering of these systems might be inevitable in order to meet future requirements. It has already been argued in the literature that the general feeling that Object-Oriented Programming promotes reuse and expandability by its very nature is rather a misconception as none of these issues is enforced. Rather, a software system must be specifically designed for reuse and expandability. Our work concentrates on the decomposition of concurrent object-oriented systems and in this paper we describe an aspect-oriented framework where both functional components and aspects are designed relatively separately from each other. This separation of concerns allows for reusability. Our goal is to achieve an improved separation of concerns in both design and implementation.