Composing concurrent objects

Adopting 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 modelling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. In addition, very little attention has been paid by the conventional object-oriented development methodologies to the analysis and design of\ud synchronisation constraints for concurrent objects.\ud To address these problems, in this thesis the framework of composition-filters, an extension to the object-oriented model, is adopted. An analysis is presented of the problems involved in reusing and extending concurrent objects, in particular the so-called inheritance anomalies. Based on this analysis, a set of criteria for effective extensible concurrent objectoriented\ud programming languages is formulated.\ud The thesis introduces techniques for the creation of concurrency and the synchronisation of concurrent activities, fully integrated within the (object-oriented) composition-filters model. Important properties of the proposed object model are: all objects are -potentially- active, intra-object concurrency is supported and synchronisation specifications are fully separated\ud from method implementations. The applicability and expressive power of the proposed technique are demonstrated, and it is shown how reusability and extensibility of concurrent objects are achieved

Examples of Reusing Synchronization Code in Aspect-Oriented Programming using Composition Filters

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

Aspect-Oriented Programming

Aspect-oriented programming is a promising idea that can improve the quality of software by reduce the problem of code tangling and improving the separation of concerns. At ECOOP'97, the first AOP workshop brought together a number of researchers interested in aspect-orientation. At ECOOP'98, during the second AOP workshop the participants reported on progress in some research topics and raised more issues that were further discussed. \ud \ud This year, the ideas and concepts of AOP have been spread and adopted more widely, and, accordingly, the workshop received many submissions covering areas from design and application of aspects to design and implementation of aspect languages

Composing Software from Multiple Concerns: A Model and Composition Anomalies

Constructing software from components is considered to be a key requirement for managing the complexity of software. Separation of concerns makes only sense if the realizations of these concerns can be composed together effectively into a working program. Various publications have shown that composability of software is far from trivial and fails when components express complex behavior such as constraints, synchronization and history-sensitiveness. We believe that to address the composability problems, we need to understand and define the situations where composition fails. To this aim, in this paper we (a) introduce a general model of multi-dimensional concern composition, and (b) define so-called composition anomalies

Initial Results for Quantifying AOP

This technical report reports on the initial result which were gathered from an controlled experiment, conducted on the the third of June, at ASML, in the Netherlands. This basically summarizes all information without much context information and much interpretation of the data

Evolvable Integration of Activities with Statecharts

The dynamic behavior of a system can be specified in statecharts,\ud and the activities of the system can be implemented in terms of\ud functions in the C programming language. Later, the statecharts\ud and the activities can be integrated to realize the system that\ud fulfils a given set of requirements.\ud \ud After the integration, the statecharts, the activities, and the\ud requirements are subject to change due to emerging necessities\ud such as bug fixes. Any change to any of these artifacts has a cost\ud in terms of effort, and risk of errors.\ud \ud In this paper, we provide a rigorous analysis of a relevant subset\ud of possible changes to activities, and their associated costs. In\ud addition, we present the overview of our solution to reduce these\ud costs.\u

Liberating Composition from Language Dictatorship

Historically, programming languages have been—although benevolent—dictators: fixing a lot of semantics into built-in language constructs. Over the years, (some) programming languages have freed the programmers from restrictions to use only built-in libraries, built-in data types, or built-in type checking rules. Even though, arguably, such freedom could lead to anarchy, or people shooting themselves in the foot, the contrary tends to be the case: a language that does not allow for extensibility, is depriving software engineers from the ability to construct proper abstractions and to structure software in the most optimal way. Instead, the software becomes less structured and maintainable than would be possible if the software engineer could express the behavior of the program with the most appropriate abstractions. The new idea proposed by this paper is to move composition from built-in language constructs to programmable, first-class abstractions in the language. As an emerging result, we present the Co-op concept of a language, which shows that it is possible with a relatively simple model to express a wide range of compositions as first-class concepts

Detecting behavioral conflicts among crosscutting concerns

Aspects have been successfully promoted as a means to improve the modularization of software in the presence of crosscutting concerns. Within the Ideals project, aspects have been shown to be valuable for improving the modularization of idioms (see also Chapter 1). The so-called aspect interference problem is considered to be one of the remaining challenges of aspect-oriented software development: aspects may interfere with the behavior of the base code or other aspects. Especially interference among aspects is difficult to prevent, as this may be caused solely by the composition of aspects that behave correctly in isolation. A typical situation where this may occur is when multiple advices are applied at the same, or shared, join point. In this chapter we explain the problem of behavioral conflicts among aspects at shared join points, illustrated by aspects that represent idioms: Parameter checking and Error propagation. We present an approach for the detection of behavioral conflicts that is based on a novel abstraction model for representing the behavior of advice. The approach employs a set of conflict detection rules which can be used to detect both generic conflicts as well as domain or application specific conflicts. One of the benefits of the approach is that it neither requires the application programmers to deal with the conflict models, nor does it require a background in formal methods for the aspect programmers

Static and Dynamic Detection of Behavioral Conflicts Between Aspects

Aspects have been successfully promoted as a means to improve the modularization of software in the presence of crosscutting concerns. The so-called aspect interference problem is considered to be one of the remaining challenges of aspect-oriented software development: aspects may interfere with the behavior of the base code or other aspects. Especially interference between aspects is difficult to prevent, as this may be caused solely by the composition of aspects that behave correctly in isolation. A typical situation where this may occur is when multiple advices are applied at a shared, join point.\ud In [1] we explained the problem of behavioral conflicts between aspects at shared join points. We presented an approach for the detection of behavioral conflicts. This approach is based on a novel abstraction model for representing the behavior of advice. This model allows the expression of both primitive and complex behavior in a simple manner. This supports automatic conflict detection. The presented approach employs a set of conflict detection rules, which can be used to detect generic, domain specific and application specific conflicts. The approach is implemented in Compose*, which is an implementation of Composition Filters. This application shows that a declarative advice language can be exploited for aiding automated conflict detection.\ud This paper discusses the need for a runtime extension to the described static approach. It also presents a possible implementation approach of such an extension in Compose*. This allows us to reason efficiently about the behavior of aspects. It also enables us to detect these conflicts with minimal overhead at runtime

An Analysis of Aspect Composition Problems

The composition of multiple software units does not always yield the desired results. In particular, aspect-oriented composition mechanisms introduce new kinds of composition problems. These are caused by different characteristics as compared to object-oriented composition, such as inverse dependencies. The aim of this paper is to contribute to the understanding of aspect-oriented composition problems, and eventually composition problems in a more general context. To this extent we propose and illustrate a systematic approach to analyze composition problems in a precise and concrete manner. In this approach we represent aspect-based composition mechanisms as transformation rules on program graphs. We explicitly model and show where composition problems occur, in a way that can easily be fully automated. In this paper we focus on structural superimposition (cf. intertype declarations) to illustrate our approach; this results in the identification of three categories of causes of composition problems. \u