Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 725 papers for “Concurrent object-oriented programming”
n.n. · 1990
Three significant trends have underscored the central role of concurrency in computing. First, there is in-creased use of interacting processes by individual users, for example, application programs running on X windows. Second, workstation networks have become a cost-effective
Cited by 0
Trevor P. Hopkins · Science of Computer Programming · 1988
Cited by 268
Tokoro, Mario, Yonezawa, Akinori · CERN Document Server (European Organization for Nuclear Research) · 1987
Cited by 0
Gul Agha · Communications of the ACM · 1990
Three significant trends have underscored the central role of concurrency in computing. First, there is increased use of interacting processes by individual users, for example, application programs running on X windows. Second, workstation networks have become a cost-effective mechanism for resource sharing and distributed problem solving. For example, loosely coupled problems, such as finding all the factors of large prime numbers, have been solved by utilizing ideal cycles on networks of hundreds of workstations. A loosely coupled problem is one which can be easily partitioned into many smaller subproblems so that interactions between the subproblems is quite limited. Finally, multiprocessor technology has advanced to the point of providing supercomputing power at a fraction of the traditional cost. At the same time, software engineering considerations such as the need for data abstraction to promote program modularity underlie the rapid acceptance of object-oriented programming methodology. By separating the specification of what is done (the abstraction) from how it is done (the implementation), the concept of objects provides modularity necessary for programming in the large. It turns out that concurrency is a natural consequence of the concept of objects. In fact Simula, the first object-oriented language, simulated a simple form of concurrency using coroutines on conventional architectures. Current development of concurrent object-oriented programming (COOP) is providing a solid software foundation for concurrent computing on multiprocessors, Future generation computing systems are likely to be based on the foundations being developed by this emerging software technology. The goal of this article is to discuss the foundations and methodology of COOP. Concurrency refers to the potentially parallel execution of parts of a computation. In a concurrent computation, the components of a program may be executed sequentially, or they may be executed in parallel. Concurrency provides us with the flexibility to interleave the execution of components of a program on a single processor, or to distribute it among several processors. Concurrency abstracts away some of the details in an execution, allowing us to concentrate on conceptual issues without having to be concerned with a particular order of execution which may result from the quirks of a given system. Objects can be defined as entities which encapsulate data and operations into a single computational unit. Object models differ in how the internal behavior of objects is specified. Further, models of concurrent computation based on objects must specify how the objects interact, and different design concerns have led to different models of communication between objects. Object-oriented programming builds on the concepts of objects by supporting patterns of reuse and classification, for example, through the use of inheritance which allows all instances of a particular class to share the same method. In the following section, we outline some common patterns of concurrent problem solving. These patterns can be easily expressed in terms of the rich variety of structures provided by COOP. In particular, we discuss the actor model as a framework for concurrent systems 1 and some concepts which are useful in building actor systems. We will then describe some other models of objects and their relation to the actor model along with novel techniques for supporting reusability and modularity in concurrent object-oriented programming. The last section briefly outlines some major on-going projects in COOP. It is important to note that the actor languages give special emphasis to developing flexible program structures which simplify reasoning about programs. By reasoning we do not narrowly restrict ourselves to the problem of program verification—an important program of research whose direct practical utility has yet to be established. Rather our interest is in the ability to understand the properties of software because of clarity in the structure of the code. Such an understanding may be gained by reasoning either informally or formally about programs. The ease with which we can carry out such reasoning is aided by two factors: by modularity in code which is the result of the ability to separate design concerns, and by the ability to abstract program structures which occur repeatedly. In particular, because of their flexible structure, actor languages are particularly well-suited to rapid prototyping applications.
Cited by 610Open access
松田裕幸, YUKO MATSUDA · Tokyo Tech Research Repository (Tokyo Institute of Technology) · 2006
Cited by 0
Bertrand Meyer · Communications of the ACM · 1993
udging by the looks of the two parties, the marriage between concurrent computation and object-oriented programming-a union much desired by practitioners in such fields as telecommunications, highperformance computing, banking and operating systems--appears easy enough to arrange. This appearance, however, is deceptive: the problem is a hard one. This article points the way toward a pos,;ible solution. The precise problem examined here is restricted to:
Cited by 171Open access
WORLD SCIENTIFIC eBooks · 1990
Cited by 1
Rafael Ramírez · Lecture notes in computer science · 1996
Cited by 7
William J. Dally, Andrew A. Chien · 1988
Cited by 2
Maria Rosa Drake · 1995
The quest for speed and the need to solve ever more complex problems has led to the development of powerful computer systems, such as the Connection Machine. Concurrent processing promises a solution to the problem. COOL (Concurrent Object-Oriented Language) has been developed in order to provide the Connection Machine with a subset of C" which includes several concurrent constructs. The Connection Machine has an inherently parallel architecture which can be taken advantage of with software.
Cited by 0Open access
Martin Henz, Gert Smolka, Jörg Würtz · 1993
Oz is a higher-order concurrent constraint programming system under development at DFKI. It combines ideas from logic and concurrent programming in a simple yet expressive language. From logic programming Oz inherits logic variables and logic data structures, which provide for a programming style where partial information about the values of variables is imposed concurrently and incrementally. A novel feature of Oz is the support of higher-order programming without sacrificing that denotation and equality of variables are captured by first-order logic. Another new feature of Oz are cells, a concurrent construct providing a minimal form of state fully compatible with logic data structures. These two features allow to express objects as procedures with state, avoiding the problems of stream communication, the conventional communication mechanism employed in concurrent logic programming. Based on cells and higher-order programming, Oz readily supports concurrent object-oriented programming including object identity, late method binding, multiple inheritance, "self", "super", batches, synchronous and asynchronous communication.
Cited by 0
莊淇銘, Chi-Ming Chung, Yen Han-Wei et al. · 1989
Cited by 1
Ole Lehrmann Madsen · 1993
A large number of different models for concurrent object-oriented programming have been proposed. None of this models have received widespread acceptance. In this paper the Simula model of quasi-parallel execution is extended to include concurrency and synchronization. Active objects may execute concurrently and access shared objects without synchronization. Synchronization may be obtained by means of semaphores. In order to avoid explicit low-level manipulation of semaphores, it is possible to build high-level concurrency abstractions that encapsulates and hide the details of the semaphores. A class library may then include abstractions corresponding to commonly used mechanisms like monitor and rendezvous. When these mechanisms are not adequate, it is possible to define new concurrency abstractions. This approach to concurrent object-oriented programming makes it possible to use many different concurrency abstractions within the same language. It is also possible to some ...
Cited by 0
柴山悦哉, ETSUYA SHIBAYAMA · Tokyo Tech Research Repository (Tokyo Institute of Technology) · 2006
Cited by 0
The MIT Press eBooks · 1993
This collection of original research provides a comprehensive survey of developments at the leading edge of concurrent object-oriented programming. It documents progress—from general concepts to specific descriptions—in programming language design, semantic tools, systems, architectures, and applications. Chapters are written at a tutorial level and are accessible to a wide audience, including researchers, programmers, and technical managers. The problem of designing systems for concurrent programming has become an increasingly important area of research in computer science with a concomitant increase in the popularity of object-based programming. Because parallelism is a natural consequence of the use of objects, the development of systems for concurrent object-oriented programming is providing important software support for a new generation of concurrent computers.
Cited by 301
de Bruin, H. · Data Archiving and Networked Services (DANS) · 2000
Cited by 0
Rafael Ramirez · 1995
This paper introduces a temporal logic based on precedence constraints among events which captures net semantics, i.e. a particular net can be mapped into a semantic-equivalent formula in the logic. Tempo, a declarative concurrent programming language, is based on such logic and has a procedural interpretation which allows specifications to be executed as concurrent programs. Thus, the execution of a net may be simulated by executing a semantic-equivalent formula as a Tempo program. Tempo++, an object-oriented extension of Tempo is presented. In this framework, concurrency issues are declaratively abstracted by temporal constraints among events. The concurrent behaviour (safety properties) of programs is explicitly specified which provides great advantages in writing concurrent programs and manipulating them while preserving correctness. Tempo++, separates concurrency issues from the code, minimizing dependency between application functionality and concurrency control, thus, increasing...
Cited by 0
Gail E. Kaiser · 1988
Concurrent object-oriented programming systems (COOPS) require support for fault tolerance, concurrency control, consistent commitment of changes and program-initiated rollback. It is sometimes suggested that the classical transaction processing model successfully applied in databases and operating systems be integrated directly into COOPS facilities. This is clearly desirable, but by itself is too limiting. COOPS applications require several granularities of transaction-like facilities. A number of transaction-like mechanisms were addressed at the workshop, and no doubt there are many others suitable for COOPS. Here I briefly survey four levels of granularity that were discussed at the workshop.
Cited by 1
Rafael Ramirez Department, Rafael Ramirez · 1995
Cited by 0
莊淇銘; Chung, Chi-ming; Yen, Han-wei; Chung, Chun-fa; Lee, Ming-chi · 1989
補正完畢
Cited by 0