An Object-Oriented Model for Extensible Concurrent Systems: the Composition-Filters Approach

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 are analyzed and presented in this paper. A set of requirements for extensible concurrent languages is formulated. As a solution to the identified problems, an extension to the object-oriented model is presented; composition filters. Composition filters capture messages and can express certain constraints and operations on these messages, for example buffering. In this paper we 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 and fulfill the requirements that were established.

[1]  Per Brinch Hansen,et al.  The programming language Concurrent Pascal , 1975, IEEE Transactions on Software Engineering.

[2]  Colin Atkinson,et al.  Object oriented concurrency and distribution in dragoon , 1991 .

[3]  Gul Agha,et al.  Research directions in concurrent object-oriented programming , 1993 .

[4]  Henry Lieberman,et al.  Using prototypical objects to implement shared behavior in object-oriented systems , 1986, OOPLSA '86.

[5]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[6]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[7]  Oscar Nierstrasz,et al.  Active objects in hybrid , 1987, OOPSLA '87.

[8]  Christian Neusius,et al.  Synchronizing Actions , 1991, ECOOP.

[9]  Alan Snyder.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[10]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[11]  Edward Yourdon,et al.  Object-oriented analysis (2nd ed.) , 1991 .

[12]  Roy H. Campbell,et al.  An overview of path Pascal's design , 1980, SIGP.

[13]  Peter Wegner,et al.  Dimensions of object-based language design , 1987, OOPSLA '87.

[14]  Mario Tokoro,et al.  Object-oriented concurrent programming , 1987 .

[15]  Jean-Pierre Verjus,et al.  Toward Autonomous Descriptions of Synchronization Modules , 1977, IFIP Congress.

[16]  Anand R. Tripathi,et al.  Communication, scheduling, and resource management in SINA , 1988 .

[17]  Bjarne Stroustrup,et al.  C++ Programming Language , 1986, IEEE Softw..

[18]  William E. Lorensen,et al.  Object-Oriented Modeling and Design , 1991, TOOLS.

[19]  Oscar Nierstrasz,et al.  Supporting Software Reuse in Concurrent Object-Oriented Languages: Exploring the Language Design Space 1 , 1991 .

[20]  HansenPer Brinch.  The programming language Concurrent Pascal , 1975 .

[21]  Maurice Herlihy,et al.  ARGUS REFERENCE MANUAL , 1987 .

[22]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[23]  Mario Tokoro,et al.  Experience and evolution of concurrent Smalltalk , 1987, OOPSLA 1987.

[24]  Roy H. Campbell,et al.  Principles of Object-Oriented Operating System Design , 1989 .

[25]  Andrew P. Black,et al.  Object structure in the Emerald system , 1986, OOPLSA '86.

[26]  Andrew P. Black,et al.  The Eden System: A Technical Review , 1985, IEEE Transactions on Software Engineering.

[27]  Mario Tokoro,et al.  Orient84/K: A Language with Multiple Paradigms in the Object Framework , 1986, IEEE Softw..

[28]  George Coulouris,et al.  Distributed systems - concepts and design , 1988 .

[29]  Anand R. Tripathi,et al.  Atomic delegation: object-oriented transactions , 1991, IEEE Software.

[30]  米沢 明憲.  ABCL : an object-oriented concurrent system , 1990 .

[31]  Lodewijk Bergmans,et al.  An Object-Oriented Language-Database Integration Model: The Composition-Filters Approach , 1992, ECOOP.

[32]  Klaus-Peter Löhr.  Concurrency annotations , 1992, OOPSLA 1992.

[33]  Anand R. Tripathi.  An Overview of the Nexus Distributed Operating System Design , 1989, IEEE Trans. Software Eng..

[34]  Anders Björnerstedt,et al.  AVANCE: an object management system , 1988, OOPSLA '88.

[35]  Michael L. Nelson,et al.  Concurrent programming in Smalltalk-80 , 1990, SIGP.

[36]  Dennis G. Kafura,et al.  Inheritance in Actor Based Concurrent Object-Oriented Languages , 1989, Comput. J..

[37]  Shreekant S. Thakkar,et al.  Programming three parallel computers , 1988, IEEE Software.

[38]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPLSA '86.

[39]  Roy H. Campbell,et al.  Synchronizing shared objects , 1995, Distributed Syst. Eng..

[40]  Edward Yourdon,et al.  Object-oriented design , 1991, Yourdon Press Computing Series.

[41]  Oscar Nierstrasz,et al.  The Next 700 Concurrent Object-Oriented Languages * , 1993 .

[42]  Narain Gehani,et al.  Ada : an advanced introduction including reference manual for the Ada programming language , 1984 .

[43]  C. Laffra.  Supporting Software Reuse in Concurrent Object-Oriented Languages : Exploring the Language Design Space , 1990 .

[44]  Dennis Kafura,et al.  ACT++: Building a Concurrent C++ with Actors , 1989 .

[45]  Anand R. Tripathi,et al.  Data abstraction mechanisms in SINA/ST , 1988, OOPSLA '88.

[46]  Anand R. Tripathi,et al.  Data abstraction mechanisms in SINA/ST , 1988, OOPSLA 1988.

[47]  Ken Wakita,et al.  Synchronization Constraints With Inheritance: What Is Not Possible --- So What Is? , 1990 .

[48]  Toby Bloom,et al.  Evaluating synchronization mechanisms , 1979, SOSP '79.

[49]  Mehmet Aksit.  On the Design of the Object-Oriented Language Sina , 1989 .

[50]  Etsuya Shibayama,et al.  Reuse of Concurrent Object Descriptions , 1991, Concurrency: Theory, Language, And Architecture.

[51]  Henry Lieberman,et al.  Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems , 1986, OOPSLA.

[52]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[53]  Roy H. Campbell,et al.  The specification of process synchronization by path expressions , 1974, Symposium on Operating Systems.

[54]  Grady Booch,et al.  Object-Oriented Design with Applications , 1990 .

[55]  Edward Yourdon,et al.  Object-oriented analysis , 2012 .

[56]  Jan Bosch,et al.  Abstracting Inter-Object Communications Using Composition-Filters , 1992 .

[57]  Jan van den Bos,et al.  PROCOL - A Parallel Object Language with Protocols , 1989, OOPSLA.

[58]  Amr El Abbadi,et al.  Implementing Fault-Tolerant Distributed Objects , 1985, IEEE Transactions on Software Engineering.

[59]  Akinori Yonezawa,et al.  Modelling and programming in an object-oriented concurrent language ABCL/1 , 1987 .

[60]  Pierre America,et al.  A parallel object-oriented language with inheritance and subtyping , 1990, OOPSLA/ECOOP '90.

[61]  Carl Hewitt,et al.  Synchronization in actor systems , 1977, POPL.

[62]  J. van den Bos,et al.  PROCOL - A Parallel Object Language with Protocols , 1989, OOPSLA.

[63]  Edsger W. Dijkstra,et al.  Co-operating sequential processes , 1968 .

[64]  A. J. Gerber.  Process synchronization by counter variables , 1977, OPSR.

[65]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[66]  Henry Lieberman,et al.  Concurrent object-oriented programming in Act 1 , 1987 .

[67]  D. Decouchant,et al.  A synchronization mechanism for typed objects in a distributed system , 1988, OOPSLA/ECOOP '88.

[68]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[69]  Klaus-Peter Löhr.  Concurrency Annotations , 1992, OOPSLA.

[70]  Vineet Singh,et al.  Inheritance and synchronization with enabled-sets , 1989, OOPSLA '89.

[71]  Gregory R. Andrews,et al.  Synchronizing Resources , 1981, TOPL.

[72]  Pierre America,et al.  Pool-T: a parallel object-oriented language , 1987 .

[73]  Per Brinch Hansen,et al.  Distributed processes: a concurrent programming concept , 1978, CACM.