E. H. Bensley, Thomas J. Brando, J. C. Fohlin et al. · 1990
Abstract : This paper describes a concurrent model of execution for object oriented programming. In addition, it describes a computation manager that implements this model and a compiler that translates a subset of Common Lisp with Flavors object oriented extension to code executable by the computation manager. Finally, fault tolerant resources management algorithms and a simulation of a multiprocessor system that embodies these algorithms are described.
Cited by 1
Elias Castegren · KTH Publication Database DiVA (KTH Royal Institute of Technology) · 2018
Since the early 2000s, in order to keep up with the performance predictions of Moore's law, hardware vendors have had to turn to multi-core computers. Today, parallel hardware is everywhere, from massive server halls to the phones in our pockets. However, this parallelism does not come for free. Programs must explicitly be written to allow for concurrent execution, which adds complexity that is not present in sequential programs. In particular, if two concurrent processes share the same memory, care must be taken so that they do not overwrite each other's data. This issue of data-races is exacerbated in object-oriented languages, where shared memory in the form of aliasing is ubiquitous. Unfortunately, most mainstream programming languages were designed with sequential programming in mind, and therefore provide little or no support for handling this complexity. Even though programming abstractions like locks can be used to synchronise accesses to shared memory, the burden of using these abstractions correctly and efficiently is left to the programmer. The contribution of this thesis is programming language technology for controlling concurrency in the presence of shared memory. It is based on the concept of reference capabilities, which facilitate safe concurrent programming by restricting how memory may be accessed and shared. Reference capabilities can be used to enforce correct synchronisation when accessing shared memory, as well as to prevent unsafe sharing when using more fine-grained concurrency control, such as lock-free programming. This thesis presents the design of a capability-based type system with low annotation overhead, that can statically guarantee the absence of data-races without giving up object-oriented features like aliasing, subtyping and code reuse. The type system is formally proven safe, and has been implemented for the highly concurrent object-oriented programming language Encore.
Cited by 5Open access
Jean-Pierre Briot Rachid, Rachid Guerraoui · 1996
This paper studies why and how Smalltalk, although designed as a mono-user and mono-processor programming language, is a very good foundation for concurrent and distributed programming. The two main reasons behind this likely paradox are: the rich and reusable library of classes, and the extreme flexibility of Smalltalk. These two specificities complement more general object-oriented characteristics and advantages. As examples supporting our claim, we overview two different Smalltalkbased software platforms for concurrent and distributed programming. 1 Introduction Our basic claim in this paper is that Smalltalk, although initially designed as a sequential, mono-user and mono-processor programming environment, is actually a very good basis for building concurrent and distributed programming systems. We may summarize the reasons behind our claim in the four main following points: ffl Smalltalk, as an object-based 1 language, provides good encapsulation and structuring to build ser...
Cited by 0
Mark Hills, Grigore Roşu · Illinois Digital Environment for Access to Learning and Scholarship (University of Illinois at Urbana-Champaign) · 2006
This paper introduces a framework for the rapid prototyping of object oriented programming languages. This framework is based on specifying the semantics of a language using term rewriting and a continuation-based representation of control. The notation used, called K, has been developed specifically for programming languages to overcome limitations in more general rewriting notation, and provides for more compact and modular language definitions. The K notation is used to define KOOL, a dynamic object-oriented language with many features found in mainstream object-oriented languages. The ability to rapidly prototype language features is shown both in the definition of KOOL and in the creation of a concurrent extension to the language.
Cited by 1Open access
Paolo Borba · 2007
Paulo Borba Programming Research Group Oxford University Computing Laboratory Abstract FOOPS is a functional, concurrent, object-oriented language. We give a structural operational semantics for FOOPS, considering features such as: classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, concurrency, nondeterminism and atomic execution. 1 Introduction FOOPS is a functional, object-oriented specification language with an executable subset [5, 18]. The functional part of FOOPS is derived from OBJ [8], which is a first order, purely functional language supporting an algebraic style for the specification, rapid prototyping and implementation of abstract data types. FOOPS extends OBJ by providing a simple declarative style for object-oriented programming and specification using (conditional) equations. It supports classes of objects with associated methods and attributes, ob...
Cited by 0
2007
We describe the problem of asynchronous exceptions in Eiffel’s Simple Concurrent Object-Oriented Programming (SCOOP). We discuss a range of possible solutions to further enable dependable computing in concurrent Eiffel. We propose a mechanism to handle aynchronous exceptions via a limited developer choice, including the notion of a failed or dead object, and necessarily introduce a small number of new exceptions. We additionally describe a number of mechanisms that were discarded as unsuitable. 1
Cited by 0
Phillip J. Brooke, Richard F. Paige · The Journal of Object Technology · 2007
We describe the problem of asynchronous exceptions in Eiffel's Simple Concurrent Object-Oriented Programming (SCOOP). We discuss a range of possible solutions to further enable dependable computing in concurrent Eiffel. We propose a mechanism to handle aynchronous exceptions via a limited developer choice, including the notion of a failed or dead object, and necessarily introduce a small number of new exceptions. We additionally describe a number of mechanisms that were discarded as unsuitable.
Cited by 9Open access
Vijay Saraswat, Nathaniel Nystrom, Robert Fuhrer et al. · 2006
This report provides a description of the programming language X10. X10 is a single-inheritance class-based object-oriented (OO) programming language de-signed for high-performance, high-productivity computing on high-end comput-ers supporting ≈ 105 hardware threads and ≈ 1015 operations per second. X10 is based on state-of-the-art object-oriented programming languages and de-viates from them only as necessary to support its design goals. The language is intended to have a simple and clear semantics and be readily accessible to main-stream OO programmers. It is intended to support a wide variety of concurrent programming idioms. The X10 design team consists of Ganesh Bikshandi, David Cunningham, Robert
Cited by 0
Paulo Borba, Paulo Borba, Joseph A. Goguen et al. · 1994
FOOPS is a concurrent object-oriented language. Based on FOOPS operational semantics, we define a notion of refinement, and an associated proof technique. The use of refinement for stepwise formal development of programs in FOOPS is illustrated by examples involving memory cells, and different implementations of buffers. 1 Introduction FOOPS is a concurrent object-oriented specification language with an executable subset [8, 23]. FOOPS includes a functional language derived from OBJ [10], which is a first order, purely functional language supporting an algebraic style for the specification, rapid prototyping, and implementation of abstract data types. FOOPS extends OBJ by providing a simple declarative style for object-oriented programming and specification using (conditional) equations. It supports classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, and many additiona...
Cited by 0
S. Ron Oliver · 1994
Object Oriented technology, especially Object Oriented Programming (OOP), has recently become very popular in a number of contexts, and for various applications. However, there have been relatively few reports of using OO Methods (OOM) for concurrent and real time systems (CRTS). Moreover, it has often been claimed that Ada 83 is an inappropriate language for doing OOP. This paper briefly reports successful use of OOM, with Ada, in a variety of CRTS, including a concurrent approach to discrete event simulation. Results show there are substantial benefits to using OOM with Ada, contradicting popular myth. Object Oriented Design and Implementation (OOD&I), versus OOP, is superior for developing large, complex software systems, and is better supported by Ada 83 than by “true” OO languages.
Cited by 0Open access
Jia Chen · 1998
In this paper, a concurrent object oriented programming model is presented. It consists of a group of concurrent objects which may have bodies. When the concurrent object with a body is created, its body begin to run. In this model, the synchronous message passing is adopted for inter object communication and the intra object concurrency is permitted. The object concurrency control is distributed among each method's activation condition in an object. Based on the presented model, C++ is extended. A policy is also given to transform the classes defined in the extended C++ into C++ classes. The implementation uses the multithreading and synchronization mechanisms supported in some multitasking operating systems, such as Windows 95.
Cited by 0
A. A. Chien, W. J. Dally · ACM SIGPLAN Notices · 1990
To program massively concurrent MIMD machines, programmers need tools for managing complexity. One important tool that has been used in the sequential programming world is hierarchies of abstractions. Unfortunately, most concurrent object-oriented languages construct hierarchical abstractions from objects that serialize — serializing the abstractions. In machines with tens of thousands of processors, unnecessary serialization of this sort can cause significant loss of concurrency. Concurrent Aggregates (CA) is an object-oriented language that allows programmers to build unserialized hierarchies of abstractions by using aggregates. An aggregate in CA is a homogeneous collection of objects (called representatives) that are grouped together and may be referenced by a single aggregate name. Aggregates are integrated into the object model, allowing them to be used wherever an object could be used. Concurrent Aggregates also incorporates several innovative language features that facilitate programming with aggregates. Intra-aggregate addressing aids cooperation between parts of an aggregate. Delegation allows programmers to compose an concurrent aggregate behavior from a number of objects or aggregates. Messages in CA are first class objects that can be used to create message handling abstractions (they handle messages as data). Such abstractions facilitate concurrent operations on aggregates. Continuations are also first class objects. In addition, programmers can construct continuations and use them just like system continuations. User constructed continuations can implement synchronization structures such as a barrier synchronization.
Cited by 4
Et D'imagerie Industrielle, Projet Lora, Michel Augeraud et al. · 1995
If object oriented programming languages o#er a good support for modularity and encapsulation. Parallelism necessitate to integrate mechanisms of control. And particularly controls of temporal aspects have to be added. Concurrent object behavior may be complex. It expresses causality relationship between events, possible concurrent method activation, methods activation depending on the object state or regarding methods' activity. Behavior specification is not only necessary but it facilitates behavior expression allowing compositional form. We can notice even if this aspect is not developed in this paper that behavior of an object can be reused to specify another behavior. In this paper we present a model of behavior control for concurrent objects using a reactive asynchronous language. And we give a logical representation of this control using a constraint programming language. This model and its representation allow proofs. Keywords : Object, Concurrency, Reactive languages 1 Introdu...
Cited by 0
Intelligenz Gmbh, Gert Smolka, Deutsches Forschungszentrum · 1994
Oz is a concurrent language providing for functional, object-oriented, and constraint programming. This paper defines Kernel Oz, a semantically complete sublanguage of Oz. It was an important design requirement that Oz be definable by reduction to a lean kernel language.
Cited by 0
Oscar Nierstrasz, Michael Papathomas · ACM SIGPLAN Notices · 1990
Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object-oriented programming. We propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. We indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. Finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.
Cited by 17
Oscar Nierstrasz, Michael Papathomas · 1990
Following our own experience developing a concurrent object-oriented language as well of that of other researchers, we have identified several key problems in the design of a concurrency model compatible with the mechanisms of object-oriented programming. We propose an approach to language design in which an executable notation describing the behaviour of communicating agents is extended by syntactic patterns that encapsulate language constructs. We indicate how various language models can be accommodated, and how mechanisms such as inheritance can be modeled. Finally, we introduce a new notion of types that characterizes concurrent objects in terms of their externally visible behaviour.
Cited by 34
Shakuntala Miriyalay, Gul Agha, Yamina Sami · 2012
The Actor model of concurrent computation unifies the functional and object-oriented programming language paradigms. The model provides a flexible basis for concurrent programming. It supports local state, dynamic creation and configuration, and inherent parallelism. Because of the fluidity of Actors, specifying and debugging actor systems is often considered difficult. We believe visual programming techniques are of fundamental importance in addressing powerful concurrent systems of this nature. Not surprisingly, a number of methods to visualize actor programs have been proposed. We give an outline of visualization techniques and their relation to actors. We then discuss one such proposal, namely the use of Predicate Transition nets, to visualize actor programs.
Cited by 0
Wen Dongcha · 1997
Under the circumstance of workstation clusters, the object-oriented technique is widely believed to be able to reduce the difficulties of the paralllllel pro gram design and improve the maintainability,portability and reusability of the programs. This paper introduces several methods of concurrent C + + implementation , including a message-passing based MPC+ +, a shared-object based SOC++and an object-level concurrent language CCPP. The language model, the programming interface, the implementation, and the performance evaluation of these languages are briefly described in this paper.
Cited by 0
Corina Cirstea, Corina Cirstea · 1995
FOOPS is a concurrent object-oriented specification language for which an operational semantics has been provided. This paper gives an equivalent distributed semantics which describes how FOOPS objects co-operate in evaluating a program. The distributed semantics is presented using transition systems. We relate transition systems and sheaves to also give a sheaf-theoretic semantics. By implementing the distributed semantics in Eqlog, we obtain a FOOPS simulator. Thus, our distributed semantics is both axiomatic and executable. 1 Introduction This paper gives a distributed operational semantics to FOOPS, a concurrent object-oriented specification language, uses transition systems and sheaf theory in formalising it and proves its equivalence to (a subset of) an already existing operational semantics of FOOPS. FOOPS (Functional and Object Oriented Programming System) combines the functional and object-oriented paradigms in order to offer both a declarative style of design and a notion of...
Cited by 0
Arastirma Merkezi Komutanligi · 2008
As processing and time requirements of computer systems increase over the borders of single processor architectures, it is becoming more and more attractive to use distributed computing with additional real-time capabilities. In several cases, traditional programming languages have become insufficient to build distributed systems easily, especially when real-time issues and basic software quality factors are concerned. In this paper, a concurrent, object-oriented, distributed real-time programming language, CPL, with a supportive run-time system, namely the CORD-RTS, is introduced and new language features are described. The new language provides an efficient solution for command and control systems by embedding distribution and real-time issues within new language constructs. The language preprocessor translates these language constructs into portable C++ code to establish run-time connection with the RTS, which provides real-time communication between distributed objects. Key Words: concurrent, object-oriented, real-time, distributed, programming language 1.
Cited by 0