Concurrent Object Oriented Programming in Python with ATOM 1st Conference on Python

Object-oriented mechanisms, such as classes and inheritance, and concurrency mechanisms, such as threads and locks, provide two separate software structuring dimensions. The development of concurrent objectoriented software requires both dimensions to be taken into account simultaneously. Previous research has identified that substantial effort is required by programmers to avoid clashes in structuring software along these separate dimensions. This has led to the design of concurrent object-oriented programming models that integrate object-oriented features with concurrent execution and synchronization, eliminating the need to consider two separate dimensions when developing concurrent object-oriented software. Although several issues that have to be addressed by such programming models have been identified, there is no consent on a programming model that addresses all these issues simultaneously. In addition, little experience has been gained from the use of proposals addressing these issues. We have used Python to prototype and experiment with the use of a novel concurrent object-oriented programming model called ATOM. In this paper we present the model’s main features and illustrate their use for concurrent programming in Python. We also provide information on a free prototype implementation of the model. Taking advantage of Python’s extensibility we were able to prototype the model without undergoing a lengthy development effort and with no need to change the Python language or its interpreter. This work has been supported by a NATO Science Fellowship through The Norwegian Research Council and was carried out w hile being a visiting student at the Computing Department, Lanca ster University.

[1]  Andrew M. Lister The problem of nested monitor calls , 1977, OPSR.

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

[3]  Klaus-Peter Löhr Concurrency annotations for reusable software , 1993, CACM.

[4]  Denis Caromel Concurrency and reusability: from sequential to parallel , 1990 .

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

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

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

[8]  Pierre America,et al.  Inheritance and Subtyping in a Parallel Object-Oriented Language , 1987, ECOOP.

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

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

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

[12]  Maurice Herlihy,et al.  Limitations of synchronous communication with static process structure in languages for distributed computing , 1986, POPL '86.

[13]  Michel Riveill,et al.  Design and implementation of an object-oriented strongly typed language for distributed applications , 1990 .

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

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

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

[17]  G. S. Blair,et al.  A Model for Active Object Coordination and i ts Use for Distributed Mult imedia Applications , 1994 .

[18]  W. Morven Gentleman,et al.  Message passing between sequential processes: The reply primitive and the administrator concept , 1981, Softw. Pract. Exp..

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

[20]  Michael Papathomas,et al.  Concurrency in object-oriented programming languages , 1995 .

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

[22]  Michael Papathomas,et al.  ATOM: An Active Object Model for Enhancing Reuse in the Development of Concurrent Software , 1995 .

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