Mehmet Aksit

Composing crosscutting concerns using composition filters

It has been demonstrated that certain design concerns, such as access control, synchronization, and object interactions cannot be expressed in current OO languages as a separate software module [4, 7]. These so-called crosscutting concerns generally result in implementations scattered over multiple operations. If a crosscutting concern cannot be treated as a single module, its adaptability and reusability are likely to be reduced. A number of programming techniques have been proposed to express crosscutting concerns, for example, adaptive programming [9], AspectJ [8], Hyperspaces [10], and Composition Filters [1]. Here, we present the Composition Filters (CF) model and illustrate how it addresses evolving crosscutting concerns.

Abstracting Object Interactions Using Composition Filters

It is generally claimed that object-based models are very suitable for building distributed system architectures since object interactions follow the client-server model. To cope with the complexity of todays distributed systems, however, we think that high-level linguistic mechanisms are needed to effectively structure, abstract and reuse object interactions. For example, the conventional object-oriented model does not provide high-level language mechanisms to model layered system architectures. Moreover, we consider the message passing model of the conventional object-oriented model as being too low-level because it can only specify object interactions that involve two partner objects at a time and its semantics cannot be extended easily. This paper introduces Abstract Communication Types (ACTs), which are objects that abstract interactions among objects. ACTs make it easier to model layered communication architectures, to enforce the invariant behavior among objects, to reduce the complexity of programs by hiding the interaction details in separate modules and to improve reusability through the application of object-oriented principles to ACT classes. We illustrate the concept of ACTs using the composition filters model.

Discussing aspects of AOP

Aspect-oriented programming is a new evolution in the line of technology for separation of concerns technology that allows design and code to be structured to reflect the way developers want to think about the system. AOP builds on existing technologies and provides additional mechanisms that make it possible to affect the implementation of systems in a crosscutting way.Aspect-oriented programming is a new evolution in the line of technology for separation of concerns technology that allows design and code to be structured to reflect the way developers want to think about the system. AOP builds on existing technologies and provides additional mechanisms that make it possible to affect the implementation of systems in a crosscutting way.

Transactions on Aspect-Oriented Software Development II

Submission information at the series homepage and springer.com/authors Order online at springer.com ▶ or for the Americas call (toll free) 1-800-SPRINGER ▶ or email us at: customerservice@springer.com. ▶ For outside the Americas call +49 (0) 6221-345-4301 ▶ or email us at: customerservice@springer.com. Transactions on Aspect-Oriented Software Development Subseries of Lecture Notes in Computer Science Editor-in-chief: M. Südholt Series Editors: D. Hutchison (et al.)

Objects, Components, Architectures, Services and Applications for a Networked World

The contents of this volume can best be described by an excerpt from the original Call for Papers for NODe 2002. Ever evolving and increasingly powerful information and communication technologies have substantially changed the nature of global relationships, the sources of competitive advantage, and the opportunities for economic and social development. The Internet, portable computers/devices and wireless communication technologies have turned the globe into an interconnected network of individuals, firms, organizations and governments communicating and interacting with each other through a variety of channels. NODe 2002 especially focuses on topics such as object-oriented (distributed) technologies, concepts and systems, agent-related technologies and concepts, advanced database systems and the Web, and E-commerce, including both the engineering and the use of Web-based application systems. Since Java and Smalltalk play a key role in the above-mentioned areas, we considered them to be of particular interest for the conference. As systems ought to be engineered well to be able to cope with the influx of the above-mentioned technologies in a positive way, the integrative factor of software architectures and component-driven technologies, especially their demands with regards to structures (patterns and architectures) and processes (enhanced life-cycles and workflows), form additional focuses of NODe 2002. However, as in the years before, NODe 2002 was open to questions and aspects of object-oriented and Internet-based technology in general and invited submissions related to a wide variety of topics in these areas.

Real-Time Specification Inheritance Anomalies and Real-Time Filters

Real-time programs are, in general, difficult to design and verify. The inheritance mechanism can be useful in reusing well-defined and verified real-time programs. In applications developed by current real-time object-oriented languages, however, changing application requirements or changing real-time specifications in sub-classes may require excessive redefinitions although this seems to be intuitively unnecessary. We refer to this as the real-time specification inheritance anomaly. This paper introduces three kinds of real-time specification inheritance anomalies that one may experience while constructing object-oriented programs. As a solution to these anomalies, the concept of real-time composition filters is introduced. Filters affect the real-time characteristics of messages that are received or sent by an object. Through proper configuration of filters, one can specify real-time constraints, and reuse of these constraints without causing inheritance anomalies.

Obstacles in object-oriented software development

Recently, a considerable number of object-oriented software development methods have been introduced to produce extensible, reusable, and robust software. We have been involved in the development of a large number of pilot applications to form our own view on object-oriented methods. Although our experiences confirmed the claims about the benefits of object-oriented methods, we identified a number of important obstacles that are not addressed by current methods. This paper summarizes these obstacles and evaluates them with respect to our pilot applications. The aim of this paper is to make software engineers aware of problems they may encounter during object-oriented development, and to inspire researchers to initiate new research activities.

Synthesis-Based Software Architecture Design

During the last decade several architecture design approaches have been introduced. These approaches however have to cope with several obstacles and software architecture design remains a difficult problem. To cope with these obstacles this chapter introduces a novel architecture design approach. The approach is based on the concept of synthesis that is a well-known and effective problem solving technique in traditional engineering disciplines. The approach is illustrated for the design of an atomic transaction architecture for a real industrial project.

Composing Synchronization and Real-Time Constraints

There have been a number of publications illustrating the successes of object-oriented techniques in creating highly reusable software systems. Several concurrent languages have been proposed for specifying reusable synchronization specifications. Recently, a number of real-time object-oriented languages have been introduced for building object-oriented programs with real-time behavior. Composing and reusing object-oriented programs with both synchronization and real-time constraints has not been addressed adequately, although most real-time systems are concurrent. This paper analyzes the origins of the problems in composing and reusing synchronization and real-time specifications, first as separate concerns, and later as composed behavior. To overcome the so-called inheritance anomaly problems, this paper proposes modular and composable synchronization and real-time specification extensions to the object-oriented model. The applicability of the proposed mechanisms is illustrated through a number of examples.

Data abstraction mechanisms in SINA/ST

This paper describes a new data abstraction mechanism in an object-oriented model of computing. The data abstraction mechanism described here has been devised in the context of the design of Sina/st language. In Sina/st no language constructs have been adopted for specifying inheritance or delegation, but rather, we introduce simpler mechanisms that can support a wide range of code sharing strategies without selecting one among them as a language feature. Sina/st also provides a stronger data encapsulation than most of the existing object-oriented languages. This language has been implemented on the SUN 3 workstation using Smalltalk.