Beth Newman, Mitchell Payne · 2002
Two of the most active areas of programming language development over the last few years have been object-oriented and concurrent programming. This paper argues that the two programming paradigms are duals of each other which are conceptualised by many programmers in a similar way. Combining them in an integrated way provides a single powerful framework for object oriented concurrent programming. An enhancement of C++, called ClassiC, is described which provides concurrent programming. In contrast to existing concurrent versions of C and C++ the additional facilities are integrated into the compiler in a way that models processes as concurrent objects, integrating concurrency into an object-oriented programming model.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">></ETX>
Cited by 2
Huang, He · Knowledge Commons (Lakehead University) · 2017
Developing concurrent object-oriented programming (COOP) languages becomes an \nattractive research area since COOP languages are more suitable for simulation of \nreal world objects and their interactions. After reviewing fundamentals of COOP \nlanguages and analyzing existing COOP languages, we propose a concurrent object-oriented \nprogramming language: CC++-. CC++ is an extension to object-oriented \nprogramming (OOP) language C++. It is extended by introducing five keywords, \nand incorporating process concepts and communication and synchronization mechanisms \ninto C++. Meanwhile it retains the syntax and semantics of C++. The \nlanguage distinguishes class (or passive) objects from process (or active) objects. \nThe class objects are the ordinary objects in C++. The process objects, however, \nare coarse-grain concurrent entities. Each process object has a sequential control \nthread and an optional public interface that can be accessed by other process objects. \nThe communication and synchronization between interacting process objects \nare accomplished through remote function call (RFC), which is an extension of remote \nprocedure call (RPC) [Han78]. Two types of RFCs, blocked RFC and unblocked RFC \nare distinguished in CC++. The blocked RFC, along with guarded function and \nforward mechanism performs synchronous message passing. The unblocked RFC, \nhowever, provides a way to express asynchronous message passing. The guarded \nfunction is based on guarded commands [Dij 75], and is introduced for expressing and \ncontrolling indeterminism. The language has been implemented as an experimental \nsystem running on UNIX. The important objectives of CC++ are ease of programming, \nsimple syntax, clear semantics and strong expressive power.
Cited by 0Open access
Pierre Vignéras · 2007
In the very next future, applications will have to be highly concurrent to get some speedup from the new trend of chip-multithreading processor architecture. But writing concurrent applications is provably more difficult than developing sequential ones. We define three objectives a concurrent programming model should target to be massively adopted by the developer community. We propose such a model for imperative object oriented languages based on an extension of the standard synchronous reference called Asynchronous Reference that naturally provides the Asynchronous Method Invocation paradigm. Our model, though simple, has many interesting side effect issues such as inter- and intra-object concurrency degree, asynchronous policy mapping, asynchronous policy sharing, non-determinism proportion and exception handling. Our proposition can be seen as a base brick on top of which many different concurrent frameworks can be built upon. The open-source Mandala framework includes a Java implementation of our proposition.
Cited by 0
J. C. Lim, RobertE. Johnson · ACM SIGPLAN Notices · 1988
Concurrency has been with us almost from the beginning of computing. Managing and programming for concurrency is a difficult problem and various solutions have been suggested over the years. Debates on message passing vs. remote procedure call, synchronous vs. asynchronous message passing, bounded vs. unbounded buffers, active vs. passive objects etc. still continue. No solution is entirely satisfactory. Concurrent programming usually depends heavily on the nature of the problem at hand and the architecture of the target machine. Object-oriented programming brings new hope for a better solution for concurrent programming. It offers the potential of hiding the details of concurrency in high-level abstractions and using the modularity imposed by an object-oriented design to model the locality that is so important in distributed systems. However, much work in the area simply continues the debates mentioned above or investigates language design or extensions to existing languages. Although it is important to select a good set of primitives for concurrent programming, the exact set that is used will not fundamentally alter the nature of the concurrent programming problem. Continuing the above mentioned debate and trying out different combinations is unlikely to result in a major improvement. These debates have very little to do with object-oriented programming. Designing features for concurrency in OOP languages is not much different from that of other kinds of languages—concurrency is orthogonal to OOP at the lowest levels of abstraction. OOP or not, all the traditional problems in concurrent programming still remain. However, at the highest levels of abstraction, OOP can alleviate the concurrency problem for the majority of programmers by hiding the concurrency inside reusable abstractions. The real issue in object-oriented concurrent programming is not how to introduce concurrency to OOP but what OOP brings to concurrent programming. The essence of OOP is reusable abstractions. For example, the main contribution of OOP to user interface design is that it allows a programmer to ignore I/O details and to focus on the high-level design of the user interface. In the same way, application programmers will not have to be experts in concurrent programming if they can reuse implementations of abstractions that encapsulate low-level details like partitioning, communication, and synchronization. Most programmers do not want to write concurrent programs, they just want to write programs that work and that are fast. Concurrency is necessary both in real-time programming and in programming parallel computers. However, most programmers would prefer to program at a high enough level that they avoid having to be concerned with the low-level details of concurrency. Obviously, someone must discover these high-level abstractions and implement them. But the majority of programmers will be free from the low-level details of concurrent programming and can concentrate on the high-level issues of designing algorithms. Work on data-parallel programming has resulted in a number of useful abstractions. The Connection Machine has spawned a number of them[1]. The paralation model[2] represents a collection of objects as a single entity. A programmer can specify the locality among constituent objects. Paralations make good building blocks for the data parallelism style of programming. The Concurrent Data Structures of William Dally[3] also addresses data parallelism and is one of the few attempts we have seen at designing abstractions that use other kinds of parallelism, as well. However, most people working in the area of object-oriented concurrent programming rarely describe high-level abstractions. The goal of our research is to discover a set of reusable abstractions that encapsulate the details of concurrency. For this scheme to be effective, the users of abstractions must not worry about synchronization among concurrent processes. The architecture of the target machine should be as transparent as possible. Abstractions should be reusable in many applications. It may not be possible to fully realize all our goals. Some data abstractions are much easier to implement on some architectures than on others, so the target architecture will probably always have an influence on some applications. We may not discover a complete set of abstractions that cover every application. However, no software library is sufficient for every task; a library is enough if it helps solve a large fraction of our problems. Even if different target architectures require different high-level abstractions to achieve the greatest performance, we will consider a library to be successful if the complexity of concurrent programming is confined to a few well defined places so that it can be easily managed and adapted to changing environments. We are working with Smalltalk-80 to find reusable abstractions in concurrent programming. Smalltalk-80 provides an ideal environment for discovering abstractions, for organizing them, and for experimenting with them. One natural place to look for concurrency is the collection of data objects. Smalltalk-80 includes two such classes, Collection and Stream. Data parallelism is provided by subclasses of Collection with concurrent implementations of the 'enumerating' protocol. ParallelCollection presents a collection of objects like FORTRAN-8X arrays and APL matrices. A programmer can view a ParallelCollection as a single entity and express concurrent operations on it without worrying about the interactions among the elements of it. Data-flow parallelism is provided by subclasses of Stream with concurrent implementations. Various divide and conquer type algorithms can be abstracted as a WorkPool. Multiple processes take out subproblems from a WorkPool and work on them. Each process may generate more subproblems and put them back in the WorkPool. Workpools are useful for graph search algorithms such as game playing and the traveling salesman problem. We also used it to implement a parallel dataflow analysis algorithm. The abstractions that we discovered are very similar to those used by Dally, although we did not learn about his work until recently. Our favorite reason is that these abstractions are probably fundamental to parallel programming and would be discovered by anyone who approached the problem with the right attitude. A more likely reason is the common influence by Smalltalk. We plan to look into other problem domains to find more reusable abstractions. In conclusion, the most important aspect of object-oriented programming is its ability to support reusable abstraction. Although most papers on the subject of object-oriented concurrent programming emphasize language models, there are probably a number of reusable abstractions that have been discovered by application programmers and left unpublicized. Those abstractions should be publicized, discussed, and refined. Object-oriented programming can make its biggest impact on concurrent systems by generating high-level abstractions that application programmers can use to build parallel systems more easily. We should concentrate more of our effort in finding these abstractions.
Cited by 3Open access
Jean-paul Bodeveix, Christian Percebois, Salam Majoul · 2007
In this paper, we present a calculus model expressing the behavior of a system of communicating objects via multiset rewriting. Then, we introduce the composition principle allowing to synchronize several applicable rewriting rules. Finally, we interpret the so-defined model in a fragment of linear logic. keywords: concurrent rewriting system, object-oriented programming, linear logic 1 Introduction Most available concurrency models are based on architectural concepts, e.g. networks of processes communicating by means of ports, channels, shared variables, streams, ... In the parallel logic programming framework, Guarded Horn Clause-based languages like FCP [9] are mostly stream-based process models. They provide the possibility of spawning new processes communicating via streams but use extra-logic suspension mecanisms having a complex semantics. More recent languages introduce the concept of shared dataspace as main tool for coordination. They offer a set of basic associative operat...
Cited by 0
Jean-Pierre Briot · 1992
This paper discusses the introduction of new programming methodologies to computer science and practice. Programming is ongoing deep evolution because the use of computers is getting larger and wider. As a consequence, programs are becoming more complex, dynamic, and resource demanding. This implies new methodologies to help decomposing large and complex programs and running them efficiently onto new parallel machines. Object-oriented concurrent programming (OOCP at short) is one of the leading methodology to match these requirements. It is based on the notion of active and autonomous entities (named objects) which run concurrently and communicate by exchanging messages. This paper introduces the concepts of OOCP methodology and discusses its advantages. It also surveys current application fields and research issues. We then focus on the issue of introducing and teaching OOCP. We describe a platform which we designed in order to help describing and experimenting with OOCP. We finally ...
Cited by 0
Ron Perrott, Gul Agha · Lecture notes in computer science · 1997
Cited by 0Open access
Denis Caromel · 2007
This paper proposes a concurrent model that takes into account such important concerns. We insist on concept unifications: the underlying reasons that make object-oriented programming adapted to concurrency. The model characteristics, especially reusability, permit us to define a concurrent object-oriented design method.
Cited by 0
Michael Papathomas, Anders Andersen · 1997
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...
Cited by 0
Akinori Yonezawa, Yoshihiro Matsumoto · Lecture notes in computer science · 1985
Cited by 5Open access
Bart Jacobs, Frank Piessens, Jan Smans et al. · ACM Transactions on Programming Languages and Systems · 2008
Reasoning about multithreaded object-oriented programs is difficult, due to the nonlocal nature of object aliasing and data races. We propose a programming regime (or programming model ) that rules out data races, and enables local reasoning in the presence of object aliasing and concurrency. Our programming model builds on the multithreading and synchronization primitives as they are present in current mainstream programming languages. Java or C# programs developed according to our model can be annotated by means of stylized comments to make the use of the model explicit. We show that such annotated programs can be formally verified to comply with the programming model. If the annotated program verifies, the underlying Java or C# program is guaranteed to be free from data races, and it is sound to reason locally about program behavior. Verification is modular: a program is valid if all methods are valid, and validity of a method does not depend on program elements that are not visible to the method. We have implemented a verifier for programs developed according to our model in a custom build of the Spec# programming system, and we have validated our approach on a case study.
Cited by 101Open access
Joana Campos, Vasco T. Vasconcelos · Electronic Proceedings in Theoretical Computer Science · 2011
There is often a sort of a protocol associated to each class, stating when and how certain methods should be called. Given that this protocol is, if at all, described in the documentation accompanying the class, current mainstream object-oriented languages cannot provide for the verification of client code adherence against the sought class behaviour. We have defined a class-based concurrent object-oriented language that formalises such protocols in the form of usage types. Usage types are attached to class definitions, allowing for the specification of (1) the available methods, (2) the tests clients must perform on the result of methods, and (3) the object status - linear or shared - all of which depend on the object's state. Our work extends the recent approach on modular session types by eliminating channel operations, and defining the method call as the single communication primitive in both sequential and concurrent settings. In contrast to previous works, we define a single category for objects, instead of distinct categories for linear and for shared objects, and let linear objects evolve into shared ones. We introduce a standard sync qualifier to prevent thread interference in certain operations on shared objects. We formalise the language syntax, the operational semantics, and a type system that enforces by static typing that methods are called only when available, and by a single client if so specified in the usage type. We illustrate the language via a complete example.
Cited by 5Open access
Raju Pandey Browne · 1994
This paper presents a model of concurrent objectoriented programming in which specification of computational behavior is separated from specification of interaction behavior of methods. It will be shown that this compositional approach to concurrent programming avoids some of the conceptual difficulties that have plagued the integration of concurrency and object-oriented models of programs. The compositional approach to concurrent objectoriented programming leads to declarative and incremental specification of interaction behavior and thus, to object /method definitions that can be readily adapted to different parallel execution environments. The approach supports inheritance of both method and synchronization specifications. It will be shown that compositional programming avoids the so-called &quot;inheritance anomaly.&quot; 1
Cited by 0
Miguel Oliveira e Silva · The Journal of Object Technology · 2004
This article evaluates several possible approaches for integrating concurrency into object-oriented programming languages, presenting afterwards, a new language named MP-Eiffel. MP-Eiffel was designed attempting to include all the essential properties of both concurrent and object-oriented programming with simplicity and safety. A special care was taken to achieve the orthogonality of all the language mechanisms, allowing their joint use without unsafe side-effects (such as inheritance anomalies).
Cited by 1Open access
Angela Dalmonte, Mauro Gaspari · 1995
We present a study of the interaction properties of objects in concurrent object oriented programming. We identify a set of basic interaction mechanisms: object identity, asynchronous message passing, implicit receive primitive, which are closed to those of the actor model. Then, we define an actor algebra over actor terms as a basic formalism for representing the semantic of concurrent object oriented programming.
Cited by 0
Thilo Kielmann · 1994
Coordination viewed as the notion of \\managing dependencies among activities &quot; [8] is the key concept for modelling concurrent systems. In this paper, we investigate coordination from the viewpoint of programmers and programming language designers with respect to object{oriented programming. Finally, we evaluate existing object{oriented coordination models. 1
Cited by 0
Fur Kunstliche, Intelligenz Gmbh, Gert Smolka et al. · 1993
Cited by 0
Radu Grosu · 1994
In this thesis we develop a novel, implicitly typed --calculus for objects, by viewing these as extendible case--functions rather than as extendible records. This novel view, allows to unify the concepts of function, object and process into one concept, that of a functional entity which is self contained and provided with a uniform communication protocol. We use this view to give a formal foundation for both sequential and concurrent object oriented languages. In the later case, we view objects as case--functions communicating asynchronously over unbounded channels. Our calculus is a conservative extension of the polymorphic type system of Aiken and Wimmers, to include case--function extension and lazy data types. Its soundness is proven with respect to a semantical model based on ideals. Subtyping and case-- function extension play a central role in our modeling of generalization/specialization and inheritance. To model self and self--class, our calculus includes recursive types. Thes...
Cited by 4
Chang-Hyun Jo, Chan-Ho Lee, Jea Gi Son · 1998
Article Free Access Share on A realization of a concurrent object-oriented programming Authors: Chang-Hyun Jo Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, Korea Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, KoreaView Profile , Chan-Ho Lee Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, Korea Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, KoreaView Profile , Jea Gi Son Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, Korea Department of Computer Science, Kyonggi University, Suwon, Kyonggi-Do, KoreaView Profile Authors Info & Claims SAC '98: Proceedings of the 1998 ACM symposium on Applied ComputingFebruary 1998Pages 558–563https://doi.org/10.1145/330560.330928Published:27 February 1998Publication History 1citation403DownloadsMetricsTotal Citations1Total Downloads403Last 12 Months10Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF
Cited by 3Open access
Galmiche, Didier, Delzanno, Giorgio, Martelli, Maurizio · HAL (Le Centre pour la Communication Scientifique Directe) · 1998
Article dans revue scientifique avec comité de lecture.
Cited by 0