Multiple concern compositions,
method modeling & QOSE

Composing multiple aspects

Related work in the object-oriented research community

Around 1993, Oscar Nierstrasz from the University of Geneva and Karl Lieberherr from the Northeastern University were one of the few people carrying out research on separation of concerns and object composition. During my visit at the Northeastern University in 1993, we discussed about the similarities and differences between Karl's Propagation Patterns and Composition Filters. Both of these techniques were based on the separation of concerns principle. Propagation patterns separated behavior from the class structure. Behavior was inserted into the class structure through compilation. Filters were used to express and compose multiple aspects, and in our implementation at that time filters were added to objects at run-time. In 1994, Cristina Lopes and Karl Lieberherr made a publication which extended the idea of propagation patterns to concurrent programming. Again from Karl's group, Walter Hürsch and Cristina  Lopes, wrote a report on separation of concerns as an emerging paradigm [Hürsch 95]. Later, Cristina joined Gregor Kiczales' group at the Xerox Palo Alto Research Center.

Gregor Kiczales and Pierre Cointe have contributed considerably in reflective techniques and meta-programming. Further, in 1995, [Mulet 95] stated the importance of composition for reflective programming. However, they did not address the composition of multiple aspects.

In June 1996, ACM organized a workshop called Strategic Directions in Computer Science at the MIT premises. I presented a paper called Composition and Separation of Concerns in the Object-Oriented Model. At the same workshop, Gregor Kiczales presented a paper on Aspect-Oriented Programming. Karl and I found the term Aspect-Oriented Programming very intuitive. The same year, at the ECOOP'96 Composability workshop, Gregor presented a paper on Aspect-Oriented Programming [Kiczales 96]. Later, Gregor presented Aspect-Oriented Programming at the ECOOP'97 conference [Kiczales 97].

Recently, during the workshop on Multi-Dimensional Separation of Concerns in Object-Oriented Systems, which was organized at the OOPSLA'99 conference, we have realized that various approaches, such as Hyperspace (natural successive of subject-oriented programming), aspect-oriented programming and object composition are getting closer to each other. 

Our Aspects and Advanced Separation of Concerns homepage can be found here.

Composing multiple aspects using Composition Filters

In 1994, various useful filters had been already developed. Most filters were published separately within a particular domain. For example, Dispatch Filter was presented as a construct for language database integration, Meta Filter for coordinated behavior, Wait Filter for synchronization, etc. One of the advantages of Composition Filters is that filters can compose aspects in multiple domains. Until 1994, we emphasized the composability of filters within a single aspect domain, such as reusable synchronization, real-time, etc. After 1994, we started to focus on composition of multiple aspects. In 1996 we published a paper about composing synchronization and real-time specifications. In 1997, we showed how Composition Filters can be used to compose synchronization and distribution. The full composability power of Composition Filters still remains to be further exploited.

In 1997, we decided to present Composition Filters under the term Aspect-Oriented Programming. Composition Filters address the "cross-cutting" problem for certain aspects, and in addition, provide aspect composition.

Our related publications can be found here.

Implementation of Composition Filters

The implementation of Sina in 1989 did not provide conditions and multiple filter types. In 1995, during his M.Sc. study, Piet Koopmans implemented the Sina language, the first language that adopted filters, using the Smalltalk language. Piet's version supported most of the filter types.

After 1993, we decided to separate the concept of Composition Filters from the Sina language. We experimented with various prototypes. In 1995, Wietze van Dijk and John Mordhorst from the Technical Engineering School Enschede implemented filters in the Smalltalk language. For his M.Sc. thesis, Maurice Glandrup implemented filters in C++. As an M.Sc. study, Hans Wichman implemented Error and Dispatch filters in the Java language.

Several M.Sc. students worked on topics related to Composition Filters. Coen Stuurman generalized the Composition Filters model to Message Manipulators. Dirk Jan Binnema worked on composable user interface concepts to be used for visual programming of Composition Filters.

Our related publications can be found here.

Deriving architectures from domain knowledge

During my master thesis study at the Eindhoven University of Technology, I took several courses on automated design of electronic circuits. My thesis supervisor was Prof. Jess, who was leading the Computer Aided Design group. When I started with the pilot projects on object-oriented software development in 1987, I interpreted the real-world modeling concepts of object-orientation from the CAD perspective. For example, in our OOPSLA'92 publication we stated the following:

In each of the pilot studies we carefully considered the available domain knowledge. We tried to identify classifications in the problem domain to map them directly into inheritance hierarchies.
....

One may not expect software engineers to organize inheritance hierarchies any better than their understanding of the classifications within the theory itself.

Actually, this view is different from the perspective of most object-oriented methods. Object-oriented methods generally advise to construct  the requirement specification first, together with the use case specifications of the system being developed. These specifications are then refined into objects and relations.

In our approach, we use the requirement specification and use cases to identify the necessary solution techniques. We then model the solution techniques, which we term as knowledge domains. The software architecture is then derived from the related knowledge domains, which are constrained by the requirement specification. Following this, the architecture is detailed by using object-oriented analysis and design methods. In other words, our approach is based on a problem synthesis process towards solutions. We would like to emphasize that constructing a domain model does not necessarily result in a synthesis. Synthesis requires a refinement of problems towards solutions.

Starting from 1993, in our pilot projects we derived software architectures from the related knowledge domains. For example, during his M.Sc. thesis, Bedir (1994) used transaction theory for designing a transaction framework. Similarly, Charles Vuijst  (1995) used image algebra for designing an adaptable image processing system. Francesco Marcelloni (1995) from the the University of Pisa, during his visit in 1995, used the fuzzy-logic theory for designing a fuzzy-logic based reasoning framework.  The results were encouraging, and therefore we decided to exploit these ideas further.

In 1995, Bedir started with his Ph.D. study and continued to work on this topic. An intensive comparative analysis of software engineering with mature engineering disciplines and philosophy has been carried out in this context.

Around 1995, Klaas van den Berg and Pim van den Broek joined the TRESE group. They participated in supervising several pilot projects.

Starting from 1994, we apply the concept of knowledge domains also in new areas which do not have always an established theory. Several M.Sc. students worked for this purpose. For example, Egbert Algra, Huub Koehorst, Maarten Hogendoorn and Johan van Dongen developed knowledge domains for supporting work-flow systems. Marc Evers applied the control theory to manage the quality of software artifacts. Ronald Willems defined a knowledge domain for designing insurance systems. Erik van der Arend defined a knowledge domain for quality management push framework.

In various consulting activities and courses, I lectured and applied the synthesis-based approach. The lessons that we learned were used to improve the technique. In March 2000, Bedir has finalized his Ph.D. thesis on the synthesis-based software architecture design.

Our Architecture Design homepage can be found here.

Our related publications can be found here.

Method modeling and fuzzy-logic techniques

After carrying out pilot projects in 13 different application domains, in our OOPSLA'92 publication, we concluded the following:

The following origins of these problems can be recognized. Firstly, some problems,.... are inherent to the object-oriented software development methods. They arise due to the size and complexity of the problem domain, and the way in which it is modeled by object-oriented methods.

Secondly, some problems are due to the process of object-oriented development....

Thirdly, the expressive power of the object-oriented computation model is too restricted to deal with the problems that involve structural relations and object interactions.

The first problem is addressed by the research activity deriving architectures from knowledge domains. The third problem is addressed by the research activity on Composition Filters. The second problem is due to limitations of object-oriented methods. To address this problem, in one of our publication we made the following comparison: 

Let us now consider computerized goods manufacturing techniques, which have been introduced to deal with similar problems like we face today in software engineering. Firstly, computer aided design environments have been developed with increasingly high-level semantic support, such as calculating the mechanical properties of the materials used. In addition, a substantial progress has been made in design automation techniques. Secondly, to be able to increase the flexibility of the production processes, computer integrated manufacturing techniques have been developed. These aim at smooth integration of various phases in the manufacturing process. Finally, to simplify the maintenance activities, design and production information have been captured and included in the delivered products as built-in information so that service engineers can retrieve this information whenever necessary.

These recent developments in goods manufacturing imply the following equivalent techniques for software industry: computer-aided design of software systems and design automation, computer-integrated manufacturing of software systems and integrating design and manufacturing information with software products.

To realize computerized software manufacturing processes, first of all, every generated product, such as architecture specification, analysis and design models, design decisions, documentation and software components must be considered as an artifact. This is necessary for reasoning about software artifacts and their manufacturing processes. Secondly, these artifacts have to be designed as intelligent software modules. Being intelligent means that every artifact defines its own rules for its creation, definition of parts, quality control and coordination with other artifacts. If artifacts are designed as intelligent software modules, they may actively assist software engineers. Thirdly, artifacts must record their context and interdependencies. This helps software engineers walk through the related artifacts, for example, from executable software modules to architecture specification artifacts. Finally, because of the complexity of the problem, artifacts must be extensible and use open-ended protocols so that new artifacts can be introduced whenever necessary.

Actually, hermeneutic software development is related to method modeling; it aims to model artifacts together with the model of the software engineer and his/her decisions. Various M.Sc. students Egbert Algra, Huub Koehorst, Bonne van Dijk, Maarten Hogendoorn, Johan van Dongen and Marc Evers worked on designing an agent-based work-flow system for supporting software engineering process. In addition, Bedir Tekinerdogan, Francesco Marcelloni, Lodewijk Bergmans, Pim van den Broek and Klaas van den Berg contributed to the artifact model.

In 1993, to model the heuristics of the software methods I decided to investigate the application of fuzzy-logic. In addition, I believed that fuzzy-logic should also help modeling object-oriented metrics. At that time, Steef de Bruijn would carry out a study on the application fuzzy-logic. At the OOPSLA'94 workshop on software metrics, we presented a paper on fuzzy-logic based metrics . The idea was received very well. Later, Steef decided to change the topic of his thesis.

In 1994, I met Francesco Marcelloni from the University of Pisa, and discussed the idea. He was very much interested. To work on the application of fuzzy-logic in modeling heuristics of methods, Francesco visited us in 1995 for about a year. The results were very exciting. We could formally and practically illustrate the benefit of the fuzzy-logic based formalization of method heuristics. To support our ideas, Francesco implemented a fuzzy-logic reasoning framework. Later, Peter Broekhuizen implemented tools for using the framework. Pim van den Broek helped us in improving the formalisms. 

It turned out that efficient implementation of the fuzzy-logic based heuristics was a serious problem. To address this issue, Pim carried out research on the implementation techniques, and he developed fuzzy-logic reasoning algorithms based on piecewise linear approximations.

In the mean time Bedir has investigated the application of two-valued logic in modeling the method heuristics. Two-valued based heuristics is closer to the rules of the current methods. We think, however, that fuzzy-logic will gradually take over the two-valued logic based formalism. Bedir has been granted a 3-years postdoc position on this topic. 

Our Fuzzy-Logic Based Automated Software Engineering homepage can be found here.

Our related publications can be found here.

Balancing quality factors and quality-oriented software engineering

The motivation for introducing Composition Filters was to enhance adaptability, composability and reusability of object-oriented programs. Until about 1994, we illustrated the quality factors of Composition Filters by using toy examples, which were referred to in sveral related publications. After 1994, we started to develop several change scenarios, and use these to illustrate the applicability of filters. For example, various related scenarios were used by Piet Koopmans and Koen Stuurman as examples. Later we decided to devote a number of master thesis studies that can explore the quality of filters by using scenarios. Steef de Bruin and Arjan Burggraaf worked out a similar scenario for C++ and CORBA implementations, respectively.

In our work on deriving architectures from knowledge domains, we defined explicit models for various application domains. We realized that there was a relation between the robustness, adaptability and reusability factors of the  software systems and the quality of the related knowledge domains. We could estimate some adaptability and reuse factors of software systems early in the development phase by inspecting the knowledge domains.

In 1996, we co-organized adaptability and composability workshops at the ECOOP conference. At the adaptability workshop, I presented a concept model for adaptability to relate the submitted papers to each other. This model seemed to be quite expressive. Later, I used this model in my courses to compare design patterns with each other, since most patterns provide some sort of adaptability.

For his Ph.D. thesis work, Bedir has been carrying out research work on adaptability modeling. Further, he has been working on modeling heuristic rules of methods.

During my professional courses, I was frequently asked how adaptability, reusability and performance factors were related and how methods could be used to balance these.

Together with Bedir, we decided to consider object-oriented modeling techniques, adaptability models and heuristic rules together. Early 1998, we started developing some formalisms. Later we realized that we were in the process of defining an algebra, which we termed as Design Algebra. I presented the early version of this work in April at the AOP ICSE workshop in Kyoto. Similarly, I started using it in my professional courses on software architectures. I presented the material during my ECOOP'98, ECOOP'99 and OOPSLA'99 tutorials. Further, I presented a seminar on this topic in the Eindhoven University of Technology and telematics Institute, and gave an invited talk at the Spanish Software Engineering conference in 1999. Based on the feedback that we received, we corrected some errors, and improved the work. In parallel, Bedir built a number of tools that implement Design Algebra within object-oriented modeling framework.

In early 1999, I proposed the Quality-Oriented Software Engineering paradigm to the TRESE group. This paradigm naturally represents many of our research activities, and therefore we decided to select it as our main stream activity. We are now in the process of re-considering our work on Composition Filters, architectures, method modeling,  correctness, etc. from the perspective of the quality factors and balancing quality factors. This means making the quality factors explicit and express these using Design Algebra. Quality-Oriented Software Engineering is a long-term goal of the TRESE group.

At the end of 1998, Arend Rensink joined the TRESE group. Arend has a formal-methods background and he is interested in designing correct object-oriented programs. We think that this will enforce our activities in Quality-Oriented Software Engineering.

Our Quality-Oriented Software Engineering homepage can be found here.

Our related publications can be found here.

Composable middleware

I was interested in distributed computing since 1982. During my compulsory military service, I made studies and wrote NATO reports on future distributed command and control systems. In 1983, within Oce, I started investigating the applicability of distributed computing for office systems.


In 1987, at the University of Twente, I established a research group on object-oriented distributed systems. Various distributed system services were investigated. In 1987, as a master thesis study, Marc van der Velden worked on various locking mechanisms. In 1988 and 1989, during the implementation of the Sina interface predicate construct, Jan Willem Dijsktra developed the Distributed Atomic Delegation mechanism. He also implemented a probe-based distributed deadlock detection algorithm. In 1989, Lodewijk Bergmans worked on distributed object systems.

In 1989 at the IBM T. J. Watson Research Center, I worked on the bulky data transfer problem.

Around 1990, Eddy Zondag joined our project. His research topic was distributed resource allocation. Master thesis students Michel van de Bempt and Hans Dolfing worked on resource allocation as well.

For about 5 years, I worked as a reviewer of the ESPRIT projects CSA, COMANDOS-1 and COMANDOS-2, which aimed at developing distributed object systems. COMANDOS projects were quite successful. Chris Horn, who was a participant of the COMANDOS projects, established IONA, which produced the leading CORBA product Orbix.

Within the context of Composition Filters, in 1992 and 1993, we introduced Meta Filter to abstract communications among objects. Further, in 1997, Arjan Burggraaf worked out a scenario to illustrate the limitations of the CORBA-based systems. He also illustrated how Composition Filters can be used to overcome these obstacles. In 1994, Bedir Tekinerdogan developed an atomic transaction framework using Composition Filters. In 1999 Ferenc Schopbarteld implemented an adaptive control system for Bedir's transaction system.

Recently, there has been a consensus on the importance of object and component technology for constructing distributed systems. However, existing object systems are not composable enough to deal with the dynamic demands of the emerging distributed systems. In 1998, we co-established the AMIDST project to investigate the composable middleware technology. Our concern is to design adaptable and composable middleware systems. In 1999 Lodewijk returned from working for Ericsson-Lund, and joined our group.    


Our related publications can be found here.

References

This page was last modified by Mehmet Aksit on December 27, 2000.