Murat Karaorman, John Bruno · Communications of the ACM · 1993
A SEQUENTIAL LANGUAGE e introduce concurrency to the object-oriented language Eiffel through a set of Class Libraries and an associated concurrent programming design method. This concurrency mechanism is well suited for client/server style distributed applications. The essential principles of sequential object-oriented programming offered by Eiffel are not sacrificed, since no changes are made to the Eiffel Language [19], or its run-time system. Our concurrency abstractions are presented as encapsulated behavior of Eiffel objects that can be inherited from the CONCURRENCY Class. Although the design described here is specific to the Eiffel language, most of these abstractions are generally applicable to other object-oriented languages such as C + + [14], and Objective-C [13]. The main concurrency abstractions provided by our mechanisms are objects as processes--active objects--and an asynchronous remote method invocation with data-driven synchronization. The view of objects as processes, having a protected private state and a prescribed behavior, provides the bridge to parallelism. Also the communication/synchronization aspects of concurrent programming blend well with the method invocation model of computation in object-oriented programming. There have been numerous proposals in recent years to combine concurrent programming with object-oriented programming. We can identify three distinct approaches for introducing concurrency to object-oriented systems: 1. Design a new concurrent object-oriented language COmMUN|CATmONm
Cited by 43Open access
Dongwook Shin · 2007
Introduction From the past, object oriented programming has been conceived as useful in developing large software. In another dimension, concurrency has been emerged as a notion for modelling various activities that take place concurrently in the real world. Recently, these two notions have been naturally raising an another programming paradigm, concurrent object oriented programming. So far, several concurrent object oriented programming languages have been proposed. Actor[1], ABCL[7], and Concurrent Smalltalk[6] are typical examples. Among these, ABCL (An Object Based Concurrent Language) developed by A. Yonezawa has great potential in real domains, mainly due to its proper granularity of object and easy computation model to understand. It is a language that underlies object and asynchronous message passing between them. A. Yonezawa et al. have been implementing ABCL on two multiprocessor systems, EM-4 and AP1000[5, 8]. EM-4 is a packet-driven multiprocessor developed by ETL
Cited by 0
Jean-Pierre Briot · 1990
This position paper argues that Object-Oriented Programming (OOP) is currently the best tool to prototype Object-Oriented Concurrent Programming (OOCP). Three aspects are considered: implementation, description ability, and programming environment. The Actalk system (which stands for actors in Smalltalk) is used along the discussion as an example supporting our position statement. The tutorial on Concurrent ObjectOriented Programming in this conference has also been based on such an approach. Keywords object, concurrency, actor, implementation, prototyping, classification, modularity, extensibility, inheritance, genericity, visualization, programming environment, Smalltalk-80, ConcurrentSmalltalk, Actalk. 1 Introduction The position we defend in this paper is: "Object-Oriented Programming (OOP) is currently the best paradigm to describe ObjectOriented Concurrent Programming (OOCP) [OOCP 87]" We summarized this statement in the title "equation": "OOCP = OOP + Concurrency" If we tak...
Cited by 0
Dimitri Konstantas, Michael Papathomas · Archive ouverte UNIGE (University of Geneva) · 1990
In this paper we address the effective use of the object-oriented programming approach for concurrent programming from a language design viewpoint. We present a set of requirements for the design of concurrent object-oriented languages. We then use a particular language, Hybrid, as a concrete example and examine to what extent its features meet these requirements. We identify the solutions offered by Hybrid and its shortcomings and we underline both the difficulties and promising directions for the design of concurrent object-oriented languages.
Cited by 8Open access
Programming Droop Eugster, P. Eugster · 2007
The Simple Object-Oriented Concurrent Programming (SCOOP) model proposed by Bertrand Meyer and illustrated through the Ei#el programming language is a simple yet powerful model for concurrent programming.
Cited by 0
Martin Henz, Martin Müller · 1995
This report gives a tutorial introduction to the basic programming paradigms in Oz. Oz is a concurrent language providing for functional, object-oriented, and constraint programming. We concentrate on functional and object-oriented programming and discuss issues of concurrency.
Cited by 0
Raju Pandey, J. C. Browne · 2007
There is significant interest in concurrent programming due to widespread availability of parallel and distributed systems. The design and implementation of concurrent programs for the parallel and distributed systems has proven to be extremely difficult. Concurrent programs are difficult to design, implement, and maintain because changes in a concurrent program (through addition of new components or modification of existing components) requires re-implementation of some or all components. Also, it is difficult to reuse specifications of components and interactions. Concurrent object-oriented programming languages show promise in alleviating the modularity and extensibility problems. Concurrent objects form a natural basis for modeling entities of applications. Further, extensibility is naturally supported through the notion of inheritance. Many object-oriented programming languages [3, 5, 1, 2] have been proposed that extend a sequential object-oriented programm
Cited by 0
Michele Perrelli, Francesco Cosco, Giuseppe Carbone et al. · Machines · 2021
Assessing passenger cars’ dynamic performance is a critical aspect for car industries, due to its impact on the overall vehicle safety evaluation and the subjective nature of the involved handling and comfort metrics. Accordingly, ISO standards, such as ISO 4138 and ISO 3888, define several specific driving tests to assess vehicle dynamics performance objectively. Consequently, proper evaluation of the dynamic behaviour requires measuring several physical quantities, including accelerations, speed, and linear and angular displacements obtained after instrumenting a vehicle with multiple sensors. This experimental activity is highly demanding in terms of hardware costs, and it is also significantly time-consuming. Several approaches can be considered for reducing vehicle development time. In particular, simulation software can be exploited to predict the approximate behaviour of a vehicle using virtual scenarios. Moreover, motion platforms and detail-scalable numerical vehicle models are widely implemented for the purpose. This paper focuses on a customized simulation environment developed in C++, which exploits the advantages of object-oriented programming. The presented framework strives to perform concurrent simulations of vehicles with different characteristics such as mass, tyres, engine, suspension, and transmission systems. Within the proposed simulation framework, we adopted a hierarchical and modular representation. Vehicles are modelled by a 14 degree-of-freedom (DOF) full-vehicle model, capable of capturing the dynamics and complemented by a set of scalable-detail models for the remaining sub-systems such as tyre, engine, and steering system. Furthermore, this paper proposes the usage of autonomous virtual drivers for a more objective evaluation of vehicle dynamic performances. Moreover, to further evaluate our simulator architecture’s efficiency and assess the achieved level of concurrency, we designed a benchmark able to analyse the scaling of the performances with respect to the number of different vehicles during the same simulation. Finally, the paper reports the proposed simulation environment’s scalability resulting from a set of different and varying driving scenarios.
Cited by 7Open access
Jean-pierre Briot · 1990
This position paper discusses the following statement: \\Object-Oriented Programming (OOP) is currently the best paradigm to describe Object-Oriented Concurrent Programming (OOCP)". Three aspects are considered: implementation, description ability, and programming environment. The Actalk system (which stands for actors in Smalltalk) is used along the discussion as an example supporting our position statement. Keywords object, concurrency, actor, implementation, message, description, classication, class, modularity, inheritance, genericity, visualization, programming environment, Smalltalk-80, Actalk 1 Introduction The position we defend in this paper is: \\Object-Oriented Programming (OOP) is currently the best paradigm to describe Object-Oriented Concurrent Programming (OOCP)" We summarized this statement in the title \\equation": \\OOCP = OOP + Concurrency" If we take a reective approach, OOCP itself would be the best candidate to describe OOCP. Reection is a very promising r...
Cited by 0
Michael Papathomas, Dimitri Konstantas · 1990
In this paper we address the effective use of the object-oriented programming approach for concurrent programming from a language design viewpoint. We present a set of requirements for the design of concurrent object-oriented languages. We then use a particular language, Hybrid, as a concrete example and examine to what extent its features meet these requirements. We identify the solutions offered by Hybrid and its shortcomings and we underline both the difficulties and promising directions for the design of concurrent object-oriented languages. 1. Introduction. Apart from the more standard features supported by object-oriented languages[14], such as encapsulation and inheritance, there is a growing interest in the design of object-oriented languages that attempt to integrate a multitude of other features within the basic object-oriented framework, such as polymorphic type systems, concurrency, persistence and distribution. The integration of these features in object-oriented language...
Cited by 0
Aihua Ren · 2000
An approach to concurrent software development is proposed. The article introduces the implemented principles of an integrated development environment for concurrent software based on object oriented Petri nets (OOPN) with multi-computer coordinate working. Under this method, two programming levels of concurrent software design are adopted. The top level is for concurrent part modeling by drawing object oriented Petri net pictures. The bottom level is for sequential part programming by using traditional high level languages. OOPN-IDE (Object Oriented Petri Net based Integrated Development Environment) is the research result for the methodology (J. Niu, 1999). It can make both the concurrent part of Petri net pictures and the sequential part of high level language programs be integrated as a whole concurrent program autamatically.
Cited by 6
José Meseguer · 1994
Abstract : This final report summarizes the research performed for the Office of Naval Research under Contract N00014-90-C-0086 on the topic Object-Oriented Design and Specification. The project began on 1 January 1990 and ended on 31 December 1994. Dr. Jose Meseguer was the project leader. Drs. Patrick Lincoln, and Narciso Martf-Oliet and Mr. Timothy Winkler also worked on the project. Early in the project, an important breakthrough took place with the discovery of rewriting logic, which was then further developed 25, 23, 26. Rewriting logic has proved to be a very flexible multiparadigm logic 27 of great simplicity allowing the unification of equational programming, Horn logic programming, object-oriented programming, and concurrent programming. In particular, a very simple semantics can be given in rewriting logic to concurrent object-oriented programming 24, 29, 28 and to object- oriented databases 33. This is particularly encouraging given that concurrent object-oriented programming and object-oriented databases are disciplines generally considered to lack a precise semantics . Encouraged by these results, a preliminary language design for Maude, a wide-spectrum multiparadigm language based on rewriting logic and containing a subset called Simple Maude that can be efficiently compiled onto a wide variety of parallel machines has been developed 34, 27, 30, 28, 17; and very encouraging experience about its suitability for specifying concurrent systems, AI problems, programming languages, and logics has been gathered 30, 20, 21, 32, 22. In addition, some initial progress has been made on transformation and compilation techniques for the Simple Maude parallel programming sublanguage 17,18.
Cited by 0
Akinori Yonezawa, Satoshi Matsuoka, Masahiro Yasugi et al. · 1992
: Novel software technologies for implementing concurrent object-oriented languages on different types of multicomputers (including stock multicomputers) are presented. Performance numbers suggest that concurrent object-oriented programming on currently available multicomputers is highly viable and promising in performance, thus allowing us exploit the computing power and modeling power provided in the concurrent object-oriented paradigm. 1 Introduction The trend toward object-oriented (OO) software construction is becoming more and more prevalent. Important software concepts such as encapsulation promote a high degree of code re-use and clean architectural structuring of large software. High-performance parallel programming, previously performed in the context of more conventional programming languages, would also be able to enjoy the benefit from the OO technology with appropriate OO languages and systems. Although many OO languages currently in use today (such as C++[15] and Smallt...
Cited by 0
Adriana Lopes Diaz · 1996
In recent years, distributed computing has received considerable attention in both academia and industry. In particular, the importance of simulating distributed algorithms (for validation and demonstration purposes) is now commonly acknowledged. But the inherent complexity and concurrency of distributed algorithms makes them difficult to simulate. In order to address this problem, the use of computational reflection has been proposed. Given the widespread adoption of the object-oriented paradigm for software development, it follows that the simulation of distributed algorithms should be tackled using a concurrent reflective and object-oriented programming language.
In this dissertation, we investigate this hypothesis. More specifically, we study the relevance of the concurrent reflective object-oriented programming language ABCL/R2 for the simulation of a representative set of distributed algorithms. Our work is three-fold: We first motivate and introduce our set of representative target algorithms. We then justify our choice of ABCL/R2 as the language of implementation. To do so, we survey relevant programming languages and libraries available for object-oriented simulation. But, most importantly, we discuss at length the numerous simulations we have implemented in ABCL/R2. Finally, we conclude by proposing a methodology for the design of simulations of distributed algorithms in a concurrent reflective object-oriented programming language. Our thesis is that this body of work does indeed confirm the relevance and importance of using a concurrent reflective object-oriented programming language for the simulation of distributed algorithms.
Cited by 0Open access
José Meseguer · 1990
A new theory of concurrent objects is presented. The theory has the important advantage of being based directly on a logic called rewriting logic in which concurrent object-oriented computation exactly corresponds to logical deduction. This deduction is performed by concurrent rewriting modulo structural axioms of associativity, commutativity and identity that capture abstractly the essential aspects of communication in a distributed object-oriented configuration made up of concurrent objects and messages. Thanks to this axiomatization, it becomes possible to study the behavior of concurrent objects by formal methods in a logic intrinsic to their computation. The relationship with Actors and with other models of concurrent computation is also discussed. A direct fruit of this theory is a new language, called Maude, to program concurrent object-oriented modules in an entirely declarative way using rewriting logic; modules written in this language are used to illustrate the main ideas with examples. Maude contains OBJ3 as a functional sublanguage and provides a simple and semantically rigorous integration of functional programming and concurrent object-oriented programming.
Cited by 101Open access
José Meseguer · ACM SIGPLAN Notices · 1990
A new theory of concurrent objects is presented. The theory has the important advantage of being based directly on a logic called rewriting logic in which concurrent object-oriented computation exactly corresponds to logical deduction. This deduction is performed by concurrent rewriting modulo structural axioms of associativity, commutativity and identity that capture abstractly the essential aspects of communication in a distributed object-oriented configuration made up of concurrent objects and messages. Thanks to this axiomatization, it becomes possible to study the behavior of concurrent objects by formal methods in a logic intrinsic to their computation. The relationship with Actors and with other models of concurrent computation is also discussed. A direct fruit of this theory is a new language, called Maude, to program concurrent object-oriented modules in an entirely declarative way using rewriting logic; modules written in this language are used to illustrate the main ideas with examples. Maude contains OBJ3 as a functional sublanguage and provides a simple and semantically rigorous integration of functional programming and concurrent object-oriented programming.
Cited by 15
M. Erhan Sarıdoğan · Istanbul Technical University Academic Open Archive (Istanbul Technical University) · 2000
Cited by 4Open access
Dan Mircea Suciu · 2001
Object-oriented concurrent programming is a methodology that seems to satisfy nowadays requirements for complex application development. Issues like inheritance anomalies or developing of object models that integrate in a natural way concurrent programming elements with object-oriented concepts was intensely analyzed in literature. Construction of a consistent modeling mechanism that ameliorates the inheritance anomalies as much as possible represents the main goal of our research work ([13], [14]). This paper presents the implementation of this modeling mechanism into a CASE tool for analysis and design of concurrent object-oriented applications. Developing specific scalable statecharts for behavior modeling of active objects and automatic code generation are subsequent issues that are attend to validate the executability of our mechanism.
Cited by 0
Sang-Hoon Kim, Seman Oh · 2002
Sequential object-oriented languages have many constraints that cannot properly represent the real world with concurrency and execution on multiprocessor computers. We present a mechanism to support the concurrency in an object-oriented language. By doing so, the programming power and adaptabilities in various applications can be improved. The underlying concept of the mechanism is to unify the notions of object and process to the active object. So, the object and process can be treated in a consistent manner. We also try to improve the encapsulation and reusability that are advantages of object-oriented programming languages. We suggest an implementation method of the concurrent object-oriented programming language. The message passing mechanism used in this work supports both synchronous and asynchronous method calls. The object model is based on a single threaded one. We implemented the concurrent object-oriented system by using Lex/Yacc and Task library.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 0
Phillip C.‐Y. Sheu, Sang‐Jo Yoo · International Journal of Human-Computer Interaction · 1989
In this paper, we describe a knowledge‐based software environment (KBSE) which supports concurrent programming based on the framework of object‐oriented knowledge base. The object‐oriented knowledge base framework combines an object‐oriented data model with the logic programming paradigm. In KBSE, the user can describe a concurrent process with a set of (sequential) flowcharts and a set of coordination constraints and integrity constraints specified in a high level description language. The description is then synthesized into a Petri net representation. With the Petri net representation, existing analysis tools for Petri net can be fully utilized to assist the design and analysis of concurrent processes.
Cited by 2