Applying Composition Filters
for the Development and Reuse
of Concurrent Object-Oriented Programs
(ISBN 90-9007359-0)
* Abstract * Table of Contents * How 2 get it * Lodewijk Bergmans *
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 modelling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. In addition, very little attention is paid to the analysis and design of synchronisation constraints for concurrent objects by the conventional object-oriented development methodologies.
To address the identified 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. A set of criteria for effective extensible concurrent languages is formulated.
The thesis introduces techniques for the creation of concurrency and the synchronisation of concurrent activities, fully integrated within the composition-filters model. Important properties of the object model are: all objects are potentially active, support for intra-object concurrency and the full separation of synchronisation specifications from method implementations. The applicability and expressive power are demonstrated, and it is shown how these techniques address reusability and extensibility of concurrent objects.
The implementation aspects that are involved in the proposed synchronisation scheme are addressed, and some optimisation techniques are presented. It is also shown how the synchronisation specifications can be translated into boolean synchronisation constraints on messages; this is applicable both for implementation purposes and for reasoning about synchronisation specifications.
To employ the proposed techniques in the development of concurrent applications, a software development method is introduced that focuses on the analysis and specification of synchronisation constraints for objects. A framework for a complete analysis and design method is introduced, incorporating a graphical notation and a number of method steps. This includes a graphical notation for specifying synchronisation constraints, and a number of steps and hints for the derivation of reusable synchronisation specifications. The graphical notation can be translated algorithmically to composition-filters synchronisation specification.
The presented material can aid software engineers in the development of concurrent object-oriented applications in several ways: potential problems in reusing and extending concurrent objects are made explicit and analysed, a technique is presented to overcome these problems, and the issue of how to analyse and design synchronisation constraints, including an intuitive and precise notation, is addressed.
1.2.1 The Object-Oriented Model
1.2.2 Object-Oriented Software Development
1.2.3 A Graphical Notation for Objects
2.3.1 The Extended Composition-Filters Object Model
2.3.2 The Principles of Composition Filters
2.3.3 The Filter Mechanism
2.3.4 Syntax of Filter Specifications
2.3.5 A Formal Description of Message Processors
2.4.1 The Components of the Interface Part
2.4.2 Defining the Interface Part in Sina
2.4.3 Data Abstraction Techniques with Composition Filters.
2.4.4 Multiple Views & Preconditions with the Error Filter
2.4.5 Abstracting Object Interactions with Meta Filters
2.6.1 The Composition-Filters Object Model (CFOM)
2.6.2 The Composition Filters Computation Model (CFCM)
2.7.1 Related Work
2.7.2 Evaluation
3.1.1 The Need for Concurrency.
3.1.2 Models of Concurrency
3.1.3 Message Passing Semantics
3.1.4 An Overview of Synchronisation Schemes.
3.1.5 Criteria for COOPLs
3.1.6 About this Chapter
3.2.1 Reuse and Extension of Concurrent Objects
3.2.2 A Generic Framework for Synchronisation Schemes
3.2.3 The Origins of Inheritance Anomaly
3.2.4 Synchronisation Modularity
3.2.5 Synchronisation Granularity
3.2.6 Expressiveness for Synchronisation Conditions
3.2.7 Conclusion
3.3.1 The Approach
3.3.2 Creating Concurrency
3.3.3 Synchronisation with Wait Filters
3.3.4 Extension of a Concurrent Class
3.3.5 Default Synchronisation
3.4.1 User-defined Message Passing Semantics
3.4.2 An Example of Resource Management: Reader-Writer Synchronisation
3.4.3 Inter-Object Synchronisation
3.4.4 Summary
3.5.1 Evaluation of our Proposal
3.5.2 Related Work
3.5.3 Conclusion
4.1.1 Our Goal.
4.1.2 Related Work
4.1.3 Requirements
4.1.4 The Approach
4.1.5 The Organisation of this Chapter
4.2.1 Introduction
4.2.2 Basic Object Diagrams (BODs)
4.2.3 Object Structure Diagrams (OSDs)
4.2.4 Object Interaction Diagrams (OIDs)
4.3.1 A Brief Introduction to State Composition Diagrams.
4.3.2 Transitions in State Composition Diagrams
4.3.3 Composition of scds
4.3.4 Internally Concurrent Objects
4.3.5 Annotations
4.3.6 An Abstract Syntax for State Composition Diagrams
4.4.1 Introduction
4.4.2 The Running Example: Dining Philosophers
4.4.3 Step I. Object Identification
4.4.4 Step II. Specifying Objects
4.4.5 Step III. Define Structural Relations
4.4.6 Step IV. Define Object Interactions
4.4.7 Step V. Determine Synchronisation
4.4.8 Step VI. Iterating with Design Considerations
4.4.9 Step VII. Translating FODs to Composition Filters Specifications
4.4.10 Step VIII. Implementation
4.4.11 The Software Development Process.
4.5.1 Informal Description of the Translation
4.5.2 The Translation of Object Diagram Components
4.6.1 Comparison with Requirements.
4.6.2 Comparison with Related Work
4.6.3 Further Research
5.1.1 Introduction
5.1.2 Our Approach towards Performance
5.1.3 About this Chapter
5.2.1 The Abstract Syntax of Wait Filter Specifications
5.2.2 Deriving Synchronisation Constraints from Wait Filters
5.2.3 Equivalence of Synchronisation Specifications
5.3.1 Problem Statement & Approach
5.3.2 The Algorithm
5.3.3 An Example
5.3.4 Conclusions
Defining Abstract Syntax
Meaning Functions
List Manipulation
The most straightforward and efficient way is to FTP the postscript version (FTP now). This is a tar file that contains separate (compressed) postscript files for each section (because otherwise printers and/or printer spoolers won't be able to handle all the -35Mbytes- of data). Check the read.me file for some suggestions how to print it.
Chapter 2 of the thesis is also separately available here under the title "The Composition Filters Object Model".
If you have trouble printing the files or are unable to print the postscript files for other reasons, feel free to contact me.
* Top * Abstract * Table of Contents * How 2 get it * Lodewijk Bergmans *