Composing Synchronization and Real-Time Constraints

There have been a number of publications illustrating the successes of object-oriented techniques in creating highly reusable software systems. Several concurrent languages have been proposed for specifying reusable synchronization specifications. Recently, a number of real-time object-oriented languages have been introduced for building object-oriented programs with real-time behavior. Composing and reusing object-oriented programs with both synchronization and real-time constraints has not been addressed adequately, although most real-time systems are concurrent. This paper analyzes the origins of the problems in composing and reusing synchronization and real-time specifications, first as separate concerns, and later as composed behavior. To overcome the so-called inheritance anomaly problems, this paper proposes modular and composable synchronization and real-time specification extensions to the object-oriented model. The applicability of the proposed mechanisms is illustrated through a number of examples.

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

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

[3]  James F. Allen.  Maintaining knowledge about temporal intervals , 1983, CACM.

[4]  B. Dasarathy,et al.  Timing Constraints of Real-Time Systems: Constructs for Expressing Them, Methods of Validating Them , 1989, IEEE Transactions on Software Engineering.

[5]  E. B. Moss,et al.  Nested Transactions: An Approach to Reliable Distributed Computing , 1985 .

[6]  G. Agha.  An overview of actor languages , 1986, OOPWORK '86.

[7]  Geoffrey A. Pascoe.  Encapsulators: a new software paradigm in Smalltalk-80 , 1986, OOPSLA 1986.

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

[9]  Geoffrey A. Pascoe.  Encapsulators: A New Software Paradigm in Smalltalk-80 , 1986, OOPSLA.

[10]  Oscar Nierstrasz.  Active objects in hybrid , 1987, OOPSLA 1987.

[11]  Akinori Yonezawa,et al.  Inheritance and Synchronization in Concurrent OOP , 1987, ECOOP.

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

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

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

[15]  Akinori Yonezawa,et al.  Reflection in an object-oriented concurrent language , 1988, OOPSLA 1988.

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

[17]  Akinori Yonezawa,et al.  Reflection in an object-oriented concurrent language , 1988, OOPSLA '88.

[18]  Jean-Pierre Briot,et al.  Actalk: A Testbed for Classifying and Designing Actor Languages in the Smalltalk-80 Environment , 1989, ECOOP.

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

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

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

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

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

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

[25]  Satish K. Tripathi,et al.  Language support for the Maruti real-time system , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

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

[27]  TokudaHideyuki,et al.  Object-oriented real-time language design: constructs for timing constraints , 1990 .

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

[29]  Gary M. Koob,et al.  Foundations of Real-Time Computing: Formal Specifications and Methods , 1991 .

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

[31]  Kwei-Jay Lin,et al.  Flex : A Language for Programming Flexible Real-Time Systems , 1991 .

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

[33]  Stefano Crespi-Reghizzi,et al.  Definition of Reusable Concurrent Software Components , 1991, ECOOP.

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

[35]  Akinori Yonezawa,et al.  Hybrid Group Reflective Architecture for Object-Oriented Concurrent Reflective Programming , 1991, ECOOP.

[36]  Michel Riveill,et al.  A synchronization mechanism for an object oriented distributed system , 1991, [1991] Proceedings. 11th International Conference on Distributed Computing Systems.

[37]  Christian Neusius.  Adapting synchronization counters to the requirements of inheritance , 1991, OOPS Messenger.

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

[39]  Lodewijk Bergmans,et al.  Obstacles in object-oriented software development , 1992, OOPSLA.

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

[41]  Mehmet Aksit,et al.  Obstacles in object-oriented software development , 1992, OOPSLA 1992.

[42]  Jan Gustafsson,et al.  RealTimeTalk, an Object-Oriented Language for Hard Real-Time Systems , 1992 .

[43]  Svend Frølund,et al.  Inheritance of Synchronization Constraints in Concurrent Object-Oriented Programming Languages , 1992, ECOOP.

[44]  Mario Tokoro,et al.  DROL: an object-oriented programming language for distributed real-time systems , 1992, OOPSLA.

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

[46]  Gul A. Agha,et al.  A Language Framework for Multi-Object Coordination , 1993, ECOOP.

[47]  Satoshi Matsuoka,et al.  Highly efficient and encapsulated re-use of synchronization code in concurrent object-oriented languages , 1993, OOPSLA '93.

[48]  Ivar Jacobson,et al.  Object-oriented software engineering - a use case driven approach , 1993, TOOLS.

[49]  Akinori Yonezawa,et al.  Abstracting Object Interactions Using Composition Filters , 1993, ECOOP Workshop.

[50]  Ivar Jacobson,et al.  Object-Oriented Software Engineering , 1991, TOOLS.

[51]  Jan Bosch,et al.  Real-Time Specification Inheritance Anomalies and Real-Time Filters , 1994, ECOOP.

[52]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[53]  Cristina V. Lopes,et al.  Abstracting Process-to-Function Relations in Concurrency Object-Oriented Applications , 1994, ECOOP.

[54]  Louis Marie Johannes Bergmans,et al.  Composing Concurrent Objects , 1994 .

[55]  Ciaran Mchale,et al.  Synchronisation in Concurrent, Object-oriented Languages: Expressive Power, Genericity and Inheritan , 1994 .

[56]  M. h. j. Glandrup.  Extending C++ using the concepts of composition filters , 1995 .