Paulo Borba, Paulo Borba, Joseph A. Goguen et al. · 1994
FOOPS is a 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, atomic execution, evaluation of expressions as background processes, and object protection. 1 Introduction FOOPS is a concurrent object-oriented specification language with an executable subset [13, 27]. FOOPS includes a functional language derived from OBJ [16], 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, dynami...
Cited by 3
Matthew Sowders · Digital Scholarship - UNLV (University of Nevada Reno) · 2020
Java is a general purpose object-oriented programming language that has been widely adopted. Because of its high adoption rate and its lineage as a C-style language, its syntax is familiar to many programmers. The downside is that Java is not natively concurrent. Volumes have been written about concurrent programming in Java; however, concurrent programming is difficult to reason about within an object-oriented paradigm and so is difficult to get right. occam -? is a general purpose process-oriented programming language. Concurrency is part of the theoretical underpinnings of the language. Concurrency is simple to reason about within an occam -? application because there is never any shared state; also occam -? is based on a process calculus, with algebraic laws for composing processes. It has well-defined semantics regarding how processes interact. The downside is that the syntax is foreign and even archaic to programmers who are used to the Java syntax. This thesis presents a new language, ProcessJ, which is a general purpose, process-oriented programming language meant to bridge the gap between Java and occam -?. ProcessJ does this by combining the familiar syntax of Java with the process semantics of occam -?. This allows for a familiar-looking language that is easy to reason about in concurrent programs. This thesis describes the ProcessJ language, as well as the implementation of a compiler that translates ProcessJ source code to Java with Java Communicating Sequential Processes (JCSP), a library that provides CSP-style communication primitives.
Cited by 0Open access
Benjamin Mor, Sebastian Nanz · 2016
To support developers in writing reliable and efficient concurrent programs, novel con-current programming abstractions have been proposed in recent years. Programming with such abstractions requires new analysis tools because the execution semantics often differs considerably from established models. We present a record-replay technique for programs written in SCOOP, an object-oriented programming model for concurrency. The resulting tool enables developers to reproduce the nondeterministic execution of a concurrent program, a necessary prerequisite for debugging and testing. 1
Cited by 0
Лаврів, Іван · ELARTU (Ternopil National Technical University) · 2016
Rust is a general-purpose, multi-paradigm, compiled programming language sponsored by Mozilla Research. It is designed to be a "safe, concurrent, practical language",supporting pure-functional, imperative-procedural, and object-oriented styles.
Cited by 0
1993
The problem of designing systems for concurrent programming is an important area of research in computer science.In sequential computers, software engineering considerations, such as the need for abstraction and program modularity, have led to a recent surge in the popularity of object-oriented programming.Because parallelism is a natural consequence of the use of objects, the development of systems for concurrent objectoriented programming is providing important software support for a new generation of concurrent computers.This book represents a timely collection of papers covering significant research efforts on a broad range of topics.They are written at a tutorial level and will be accessible to a wide audience, including researchers, programmers, and advanced students.The book will be particularly important to the object-oriented, parallel and distributed programming communities.The papers discuss general concepts as well as provide descriptions of specific languages, systems, and applications.Although the contributions were invited, they were subsequently refereed to ensure both the quality of content and the accessibility of the presentation.We would like to acknowledge the support of the National Science Foundation in supporting the first Workshop on Object-Based Concurrent Programming (NSF CCR-881-4055).The workshop was helpful in identifying much of the ongoing research projects in the area.We would also like to thank Rajendra Panwar for his editorial and typesetting
Cited by 0Open access
2008
This paper introduces a new language model, Coqa, for deeply embedding concurrent programming into objects. Every program written in our language has built-in the desirable behaviors of atomicity, mutual exclusion, and race freedom. Such a design inverts the default mode of e.g. Java, where programmers may write programs highly vulnerable to surprising runtime errors if they do not take advantage ofsynchronized blocks and other advanced concurrency features. Coqa takes advantage of basic object-oriented notions to express important concurrent programming primitives, resulting in a powerful but concise model that includes thread creation, shared object access and open nesting. A key property of our model is the notion of quantized atomicity: all concurrent program executions can be viewed as being divided into quantum regions of atomic execution, greatly reducing the number of interleavings to consider. The language design draws from different schools of concurrent language design, especially Actors, and constructs a unified design close to mainstream object-oriented programming practice. We justify our approach both from a theoretical basis by showing that a formal representation, KernelCoqa, has provable quantized atomicity properties, and by implementing CoqaJava, a Java extension incorporating all of the Coqa features. 1.
Cited by 0
Luís Manuel Marques da Costa Caires · 1999
In this dissertation, we propose a framework for declarative specification and programming of modular systems with concurrency and mobility. The main contributions are the introduction and study of the core programming language Lpi, and of the dol specification logic for mobile processes. Lpi is a language that demonstrates a minimalist approach to the unification of multiple programming paradigms, by building on an interpretation of concurrent computation as proof-search in linear logic. Prominently, Lpi aims at unifying, in a uniform and tightly coupled way, a deduction-oriented computational model with a concurrent and mobile Milner-type model of interaction. We assess the expressiveness of Lpi as a programming language by showing that many concurrent and executable logic idioms can be reconstructed as its fragments, and also how it can motivate novel combinations of concurrent, functional, logic and object-oriented paradigms in a natural way. The relation
Cited by 0
Hugo Leroux, C. Exton · 2002
There has been a move to introduce concurrency and object-orientation in the undergraduate curriculum. However, both bring forth challenging new concepts to the students. Despite these challenges, the benefits gained from learning concurrent object-oriented programming are numerous. Visualisation holds great promise in expediting comprehension of such complex issues. The aim of this paper is to discuss the potential of our visualisation tool, COOPE, to assist the students in comprehending the complexities of concurrent object-oriented programs. We thus present some broad requirements of a visualisation tool and discuss the design and implementation of COOPE.
Cited by 5
Michael Hanus, Frank Huch, Philipp Niederau · 2000
. Curry combines the concepts of functional, logic and concurrent programming languages. Concurrent programming with ports allows the modeling of objects in Curry similar to object-oriented programming languages. In this paper, we present ObjectCurry, a conservative extension of Curry. ObjectCurry allows the direct denition of templates which play the role of classes in conventional object-oriented languages. Objects are instances of a template. An object owns a state and reacts when it receives a message|usually by sending messages to other objects or a transformation of its state. ObjectCurry also provides inheritance between templates. Furthermore, we show how programs can be translated from ObjectCurry into Curry by exploiting the concurrency and distribution features of Curry. To implement inheritance, we extend the type system of Curry, which is based on parametric polymorphism, to include subtyping for objects and messages. 1 Introduction Curry [4, 6] is a multi-...
Cited by 0
Eshrat Arjomandi, William G. O'Farrell, Greg Wilson · 1996
ABC++ is a portable object-oriented type-safe class library for concurrent programming. It supports active objects, synchronous and asynchronous object interactions, and object-based shared regions on both shared- and distributed-memory parallel computers. ABC++ is written in, and compatible with, standard C++: no language extensions or preprocessors are used. This paper focuses on the use of an object-oriented technique called smart messages to support object interactions. Smart messages demonstrate the effectiveness of object-oriented programming in encapsulating low-level details of concurrency and in improving software portability. 1 Introduction While massively-parallel computers and networks of workstations (NOWs) are now widely available, good programming systems for them are not. The rapid rate of architectural change has meant that the levels of code re-use which are taken for granted in conventional computing environments are still only dreamt of by parallel progra...
Cited by 1
Oscar Nierstrasz · 1992
Object-oriented programming is a powerful paradigm for organizing software into reusable components. There have been several attempts to adapt and extend this paradigm to the programming of concurrent and distributed applications. Hybrid is a language whose design attempts to retain multiple inheritance, genericity and strong-typing, and incorporate a notion of active objects. Objects in Hybrid are potentially active entities that communicate with one another through a messagepassing protocol loosely based on remote procedure calls. Non-blocking calls and delay queues are the two basic mechanisms for interleaving and scheduling activities. A prototype implementation of a compiler and run-time system for Hybrid have been completed. We shall review aspects of the language design and attempt to evaluate its shortcomings. We conclude with a list of requirements that we pose as a challenge for the design of future concurrent object-oriented languages. *.In Advances in Object-Oriented Softwa...
Cited by 27
Benjamin Mor, Sebastian Nanz · 2016
Operational semantics is a flexible but rigorous means to describe the meaning of programming languages. Small semantics are often preferred, for example to facilitate model checking. However, omitting too many details in a semantics limits results to a core language only, leaving a wide gap towards real implementations. In this paper we present a comprehensive semantics of the concurrent programming model SCOOP (Simple Concurrent Object-Oriented Programming). The semantics has been found detailed enough to guide an implementation of the SCOOP compiler and runtime system, and to detect and correct a variety of errors and ambiguities in the original informal speci-fication and prototype implementation. In our formal specification, we use abstract data types with preconditions and axioms to describe the state, and introduce a number of special operations to model the runtime system with our inference rules. This approach makes our large formal speci-fication manageable, providing a first step towards reference documents for specifying concurrent object-oriented languages based on operational semantics. 1
Cited by 0
Hidehiko Masuhara · 1994
Recent progress in implementations of object-oriented concurrent programming languages on highly-parallel processors makes it feasible to construct large-scale parallel applications having complicated structures. Such applications can not exhibit good performance without dynamic resource management (e.g., load-balancing and object scheduling) tailored to the characteristics of the applications and/or machine architectures. Since dynamic resource management systems are usually intertwined with the language implementation, modification/extension of the management systems requires complicated programming in the low-level language. Reflective systems can provide abstractions to modify/extend the implementation-level facilities within the application-level language. This study proposes a reflective architecture of an object-oriented concurrent language for highly-parallel processors to provide resource management systems for parallel applications. To make our architecture practical, much at...
Cited by 0
Hidehiko Masuhara · 1994
Recent progress in implementations of object-oriented concurrent programming languages on highly-parallel processors makes it feasible to construct large-scale parallel applications having complicated structures. Such applications can not exhibit good performance without dynamic resource management (e.g., load-balancing and object scheduling) tailored to the characteristics of the applications and/or machine architectures. Since dynamic resource management systems are usually intertwined with the language implementation, modification/extension of the management systems requires complicated programming in the low-level language. Reflective systems can provide abstractions to modify/extend the implementation-level facilities within the application-level language. This study proposes a reflective architecture of an object-oriented concurrent language for highly-parallel processors to provide resource management systems for parallel applications. To make our architecture practical, much at...
Cited by 0
Qian Zhang · Wuhan University Journal of Natural Sciences · 1998
An appropriate combination of COOP and Petri nets is required in order to profit from the strength of both methods. This paper gives an overview of our ongoing research on PN-COOPN, which is a paradigm and development environment for concurrent object-oriented programming based on Petri nets. We describe the object model and programming notation and emphasis the inheritance part for PN-COOPN.
Cited by 0
Glenn Anthony Lewis · 1996
The programming language Java has become and extremely popular language; many people are writing concurrent systems using Java. The design and implementation of concurrent Java programs is significantly more complex than sequential programs and the use formal method is seen as extremely beneficial for the design and implementation of such systems. The Petri net formalism [Petri 1962] can be used for the design, specification, simulation, verification, validation and implementation of concurrent systems. Object Petri Nets (OPNs) [Lakos 1994] represent a complete integration of Petri nets and object-orientated concepts and therefore provide the many benefits of object-orientation to the Petri net formalism. This thesis presents an examination of concurrent object-oriented languages with a particular emphasis on object-oriented Petri net languages; a review of Java is also provided. The many benefits of OPNs are seen as an ideal method for the design, specification and implementation of c...
Cited by 0
Kiyoshi·Hiberto Yabusaki, Kazuaki IWATA, Eiji Arai et al. · TRANSACTIONS OF THE JAPAN SOCIETY OF MECHANICAL ENGINEERS Series C · 1995
Computer representation of the product object is necessary for realization of concurrent engineering. This representation should be determined cooperatively by design and production departments using communication systems. This paper describes minimum design and production criteria to meet requirements and functions for modelling. The authors propose one method for representation of the product object, using object-oriented programming and an object-oriented database management system. Reliable data for this product object representation were obtained by interviewing several experienced designers and manufacturing engineers and through a literature search. Then, the authors developed a prototype and verified the validity. Based on a simple design experiment, the possibility of realizing human-centered concurrent engineering was clarified.
Cited by 0Open access
Doug Lea Co-organizer, Tim Harris Microsoft, David F. Bacon et al. · 2005
As mainstream hardware moves to multicore processors, programmers will be forced to write multithreaded programs in order to achieve high performance. One thing seems clear: mainstream programmers cannot use today’s abstractions of locks, condition variables, semaphores, and barriers to develop scalable parallel software effectively. This workshop addresses the problem of how best to express synchronization and concurrency in object-oriented multithreaded programming environments. This workshop brings together researchers working on different parts of this problem, including: frameworks and libraries for concurrent object-oriented programming, patterns in concurrent software, tools for detecting concurrencyrelated bugs, new programming abstractions, and new directions for low-level support from the operating system and hardware. SCOOL ’05 builds on the success of last year’s workshop on Concurrency and Synchronization in Java Programs (CSJP) to understand how these pieces fit together, and to define the research challenges that will adapt today’s object-oriented programming languages for tomorrow’s hardware. We thank to the members of the program committee for their thoughtful and timely reviews of the submissions. Copyrights of the articles in these proceedings are those of the authors or as indicated on each article.
Cited by 0
Steven S. Popovich · 1991
Much research has been done in the last decade in the closely related areas of object-oriented programming languages and databases. Both areas now seem to be working toward a common end, that of an object management system, or OMS. An OMS is constructed similarly to an OODB but provides a general purpose concurrent object oriented programming language as well, sharing the object base with the OODB query facilities. In this paper, we will define several different types of object systems (object servers, persistent OOPL’s, OODB’s and OMS’s) in terms of their interfaces and capabilities. We will examine the distinguishing features and general architecture of systems of each type in the light of a general model of OMS architecture.
Cited by 0
Manish Vachharajani, Neil Vachharajani, David I. August · 2008
Modeling systems in which users construct models by specifying the interconnect between concurrently executing components are a natural fit for hardware modeling. These concurrent-structural modeling systems allow the specification of the model to parallel that of the hardware making specifications clear, easy to understand, and straight-forward to build and modify. Unfortunately, many concurrent-structural modeling systems provide few mechanisms to create flexible-reusable components. Others have built these modeling systems on object-oriented programming (OOP) languages in the hope that the OOP features will allow the creation of useful flexible reusable components for structural modeling. Unfortunately, simply adopting OOP features is insufficient for this task. By drawing an analogy between OOP programs and concurrent-structural models, it is possible to understand why. Furthermore, this analogy highlights what would be needed in a concurrent-structural system to gain the same benefits seen in OOP systems. This report compares the features necessary to obtain reuse in concurrent-structural modeling systems by drawing this analogy between object-oriented programming constructs and concurrent-structural modeling constructs. 1.
Cited by 0