ing Object Interactions Using Composition Filters Mehmet Aksit 1 , Ken Wakita 2 , Jan Bosch 1 , Lodewijk Bergmans 1 and Akinori Yonezawa 3 1 TRESE project, Department of Computer Science, University of Twente, P.O. Box 217, 7500 AE Enschede, The Netherlands. email: {aksit, bosch, bergmans}@cs.utwente.nl 2 Department of Information Science, Tokyo Institute of Technology, 2-12-1 Ohokayama, Meguro-ku, Tokyo, 152, Japan. email: wakita@is.titech.ac.jp 3 Dept. of Information Science - Faculty of Science- University of Tokyo, Hongo, Bunkyo-ku, Tokyo 113 Japan. email: yonezawa@is.s.u-tokyo.ac.jp Abstract It is generally claimed that object-based models are very suitable for building distributed system architectures since object interactions follow the clientserver model. To cope with the complexity of today's distributed systems, however, we think that high-level linguistic mechanisms are needed to effectively structure, abstract and reuse object interactions. For example, the...

Building software from reusable components is considered important in reducing development costs. Object-oriented languages such as C++, Smalltalk and Java, however, are not capable of expressing certain aspects of applications in a reusable way. Software engineers may experience difficulties in composing and reusing applications from components, for example if components implement code for multiple views, dynamic inheritance and synchronization [6]. If these aspects have to be programmed, then object -oriented languages may require a considerable amount of redefinition although this may not be intuitively necessary. Several researchers termed these problems as inheritance anomalies, cross-cutting, etc. [12][8][10][11]. Aspectoriented programming aims at addressing these problems by specifying and composing the aspects of a program in a systematic way [10]. Composition-Filters is an aspect-oriented programming technique where different aspects are expressed in Filters as declarative an...

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 objectoriented languages, however, changing application requirements or changing real-time specifications in subclasses 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.

The ultimate goal of all computer science is the program. The performance of programs was once the noblest function of computer science, and computer science was indispensable to great programs. Today, programming and computer science exist in complacent isolation, and can only be rescued by the conscious co-operation and collaboration of all programmers. The universities were unable to produce this unity; and how indeed, should they have done so, since creativity cannot be taught? Designers, programmers and engineers must once again come to know and comprehend the composite character of a program, both as an entity and in terms of its various parts. Then their work will be filled with that true software spirit which, as “theory of computing”, it has lost. Universities must return to programming. The worlds of the formal methods and algorithm analysis, consisting only of logic and mathematics, must become once again a world in which things are built. If the young person who rejoices in creative activity now begins his career as in the older days by learning to program, then the unproductive “scientist ” will no longer be condemned to inadequate science, for their skills will be preserved for the programming in which they can achieve great things. Designers, programmers, engineers, we must all return to programming! There is no essential difference between the computer scientist and the programmer. The computer scientist is an exalted programmer. By the grace of Heaven and in rare moments of inspiration which transcend the will, computer science may unconsciously blossom from the labour of the hand, but a base in programming is essential to every computer scientist. It is there that the original source of creativity lies. Let us therefore create a new guild of programmers without the class-distinctions that raise an arrogant barrier between programmers and computer scientists! Let us desire, conceive, and create the new program of the future together. It will combine design, user-interfaces, and programming in a single form, and will one day rise towards the heavens from the hands of a million workers as the crystalline symbol of a new and coming faith. 1 1

A considerable number of language mechanisms have been proposed during the last several years, to specify and implement concurrent object-oriented programs. The major concern of these proposals is to design an expressive language that provides extensible concurrent processing and synchronization features. Almost all these efforts, however, have focused on the multiple-clientsingle-server model where each server determines its synchronization semantics without cooperating with other objects. We believe that object-oriented concurrent languages must not only support a single-server model, but cooperatively synchronizing servers as well. We refer to this as multi-server synchronization. This paper first classifies multi-server synchronization in five categories. The intention here is to define a framework for evaluating current approaches and identifying the requirements for designing new languages. In addition, this paper presents a composable multi-server synchronization technique, adopting the concept of composition-filters. 1.

This paper introduces a new load balancing and communication minimizing heuristic used in the Inverse Remote Procedure Call (IRPC) system. While the paper briefly describes the IRPC system, the focus is on the new IRPC assignment heuristic. The IRPC compiler maps a distributed program to a graph that represents program objects and their dependencies (due to invocations and parameter passing) as nodes and edges, respectively. In the graph, the system preserves conditional and iterative flows, records network transmission and execution costs, and marks nodes that have to reside at specific network sites. The graph is then partitioned by the heuristic to derive a (sub)optimal node assignment to network sites minimizing load balancing and network data transport. The resulting program partition is then reflected in the physical object distribution, and remote and local object communication is transparently

Applying the object-oriented paradigm for the development of large and complex software systems offers several advantages, of which increased extensibility and reusability are the most prominent ones. The object-oriented model is also quite suitable for modeling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. The problems that arise, the so-called inheritance anomalies or crosscutting aspects have been extensively studied in the literature. As a solution to the synchronization reuse problems, we present the composition-filters approach. Composition filters can express synchronization constraints and operations on objects as modular extensions. In this paper we briefly explain the composition filters approach, demonstrate its expressive power through a number of examples and show that composition filters do not suffer from the inheritance anomalies.

With system development becoming increasingly incremental, design stability stands out as one of the most desirable software quality attributes. Development of stable software systems is particularly challenging in the domain of software product lines (SPLs), where their core architecture, set of features, and multiple products are continuously evolving. Contemporary programming languages, such as Compose*, are promising solutions to support enhanced SPL stability through the notion of composition filters. Aspect-oriented and feature-oriented programming models have often being used and assessed in the context of SPL development. However, there is little empirical knowledge on which situations such composition filters mechanisms, in fact, can be used to build SPLs with superior stability. This paper presents an exploratory study that compares the stability of Compose * and AspectJ implementations through multiple releases of two product lines. These implementations are evaluated by means of independentlyvalidated stability metrics. Our results show that the use of Compose * to implement non-functional features and interacting code-sharing features often foster more stable SPL designs than AspectJ ones.