M. Kiser, A. Zogg · 1989
Object oriented programming and parallel programming are two important and evolving areas in computer science. Much research has been carried out in each of the two programming disciplines, but little effort has been put on combining the two areas. The authors discuss a major problem of parallel programming: synchronization of concurrent processes using a shared object. Discussing the example of the bounded buffer, they demonstrate how to build a high structured shared object based on primitive constructs in an object oriented manner. They use the object oriented programming environment Smalltalk-80 which supports basic process management and synchronization tools (semaphores). The ideas presented were realized in a prototype of a distributed directory service according to the CCIT X.500 standard. >
Cited by 1
Gabriele Elia, Giuseppe Menga · 2007
Object-oriented (OO) programming, by using a library of basic classes and their inheritance relationships, offers a consistent framework within which to specify, design and prototype the software architecture of complex discrete event control systems. G++ is simultaneously a design method and an analysis and design environment, and such a framework is applied to concurrent distributed systems and specifically to Computer Integrated Manufacturing (CIM). It offers library of classes for the C++ language, so that it encompasses data structures, classes to express concurrency, as well as graphical objects for specification, debugging and monitoring interfaces. The method is supported by development tools based on graphical editors to specify, design, prototype and implement distributed applications. Keywords: Object-oriented programming; concurrent object-oriented programming; CASE tool; graphical front end; prototyping; software repository navigation tool; systems development m...
Cited by 0
Wen Dongchan · 1997
COOL(concurrent object oriented language) is a kind of highly efficient concurrent programming language. In this paper, a concurrent object model (concurrent C++,CCPP ) and its language are presented. In this model, all objects are concurrent, and they communicate through asynchronous message sending. Concurrent objects are synchronized using a wait when necessary policy, and the synchronization constrains among concurrent threads within an object are described by path expressions. CCPP is an extension of C++, implemented by a precompiler. CCPP allows sequential/concurrent code reuse.
Cited by 0
Ласко Ласков · Scholar Electronic Repository of the New Bulgarian University (New Bulgarian University) · 2020
This manual gives a practical introduction to the fundamental topics of programming using Java programming language and Java framework. It covers the basics of the programming language, object-oriented programming with Java, generics programing, graphical user interface programs development, and concurrent software development.
Cited by 0
Stephan Reitzner, Stephan Reitzner · 2008
Synchronization of concurrent activities is a major issue with concurrent object-oriented programming languages, as we are dealing with fine grained synchronization involving objects and methods. In this paper we propose the separation of the synchronization code from the algorithmic, sequential code of a concurrent object, arriving at two objects: one that implements the algorithmic and sequential behavior, and the other one that is responsible for controlling concurrency. Our synchronization scheme only uses standard object-oriented mechanisms, so that it can easily be integrated into existing, sequential languages. One of the major problems of concurrent, object-oriented programming languages (COOPLs) is inheritance. Because of the strong ties between an implementation and the associated synchronization description in the base class we suffer from the inheritance anomaly. This anomaly limits the reuse of code by inheritance. By moving the synchronization code into a separate object, we divide the inheritance process into a sequential, algorithmic part and a synchronization part. This splitted inheritance dramatically reduces the number of inheritance anomalies occurring.
Cited by 0
H.C. Wang, C. K. Yuen, M.D. Feng · 2003
Run-time systems are critical to the implementation of concurrent object oriented programming languages. The paper describes a concurrent object oriented programming language, Balinda C++, running on a distributed memory system and its run-time implementation. The run-time system is built on the top of the Nexus communication library. The tuplespace is the key to Balinda C++. A distributed tuplespace model is presented to improve data locality. Some experiments have been done to verify our model. The results indicate that our model is effective at improving system performance.
Cited by 3
Sabine Glesner · 1998
We follow the trend to use inference rule based specifications when describing the semantics of imperative and object-oriented programming languages. Within manysorted natural semantics it is possible to define the static semantics of imperative and object-oriented programming languages exclusively by using inference rules. During the semantic analysis we need to infer semantic information by using the inference rules of the specification so that the semantic analysis can be considered as a proof procedure. We show how this proof procedure can be implemented efficiently by exploiting techniques known from object-oriented libraries and by using concurrent constraint programming.
Cited by 0
Guanrong Lou · 2004
Lime is an action-based object-oriented concurrent programming language, which was developed by Dr. Sekerinski from McMaster University. The development of Lime is based on the observation that more and more applications will be implemented on networks of processors in the future and those are significantly more ambitious than current applications. It is difficult for programmers to do multiprogramming using current object-oriented programming languages. Action systems, which model concurrency by nondeterministic choice among atomic actions (e.g. Lamport’s Temporal Logic of Actions, J. Misra and K. M. Chandy’s Unity Logic and Back’s Action Systems), can help us to simplify both the specification and design of concurrent applications. But all of that is still theoretical. Such action systems have not been implemented and experimented with very thoroughly. Lime is an object-oriented programming language that is based on the action system. The closest approach is Seuss, which was developed by J. Misra et.al. at The University of Texas at Austin, but the limitation of Seuss is that it is not fully object-oriented. One purpose of my research is to find out how to schedule actions for applications running on a multiprocessor environment. I implemented a compiler for this new technique that can translate programs written in Lime to Java assembly language. Object-oriented programming techniques are used widely in software development, and Lime can make a good combination of these techniques and action systems. So we can make the development of object-oriented concurrent programs much easier and efficient.
Cited by 3
Aaron Coday, Andrew A. Chien · 2007
Concurrent Object Oriented Programming introduces significant challenges for a compiler. We examine one of these challenges, access region expansion, from two perspectives; compiler runtime performance and quality of access region expansion. The work was done within the Concert Compiler framework. We found that with clever modifications the compiler runtime performance could be significantly improved ( 4X). We also found that while there are inherent limitations to the quality of access region expansion, our implementation is overly restrictive. We conclude that further work in this topic needs to be done to fully understand the problem and define an optimal solution. 1 Introduction Object-oriented programming has long been accepted as helping to manage program complexity on sequential machines. The feature is needed ever so much in the parallel computing arena. Concurrent Object-Oriented Programming (COOP) attempts to provide the abstraction and encapsulation benefits of object-orien...
Cited by 0
Murat Karaorman, John Bruno · 1991
this paper introduces concurrency to the object-oriented language Eiffel by providing a set of Class Libraries and an associated concurrent programming design method. The concurrency mechanism we provide is wellsuited for client/server style distributed applications. Since no changes are made to the Eiffel Language [19], or its runtime system, the essential principles of sequential object-oriented programming offered by Eiffel are not sacrificed. We present our concurrency abstractions 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 mechanism are objects as processes -- active objects -- and an asynchronous remote method invocation with data-driven synchronization. The extended view of objects as processes having a protected private state and a prescribed behavior, provides the bridge to parallelism, since most approaches in parallel programming are based on the notion of process. Also the communication /synchronization aspects of concurrent programming blends well with the basic message passing (or method invocation) model of computation in object oriented programming.
Cited by 0
Yang Da-jun · 2002
Synchronization between processes is one of the main features of concurrent programming. However, under the framework of concurrent object-oriented, the existence of synchronization constraints can cause undesired re-definitions of inherited code. Based on the two kinds of synchronization mechanisms in VDM++, a synchronization model, guard trace structure is presented in this paper to be applied to a wide-spectrum concurrent object-oriented specification language. This model can support not only reuse of general code, but also that of synchronization code effectively.
Cited by 0
Stephan Reitzner · 2007
Synchronization of concurrent activities is a major issue of concurrent object-oriented programming languages, as they deal with fine grained synchronization involving objects and methods. In this paper I propose the separation of the synchronization code from the algorithmic code of a concurrent object, arriving at two objects: one that implements the algorithmic behavior, and one that is responsible for controlling concurrency. I introduce an event model to carry out the link between the two objects. I also present a new way of deriving from classes with concurrency control. The inheritance step is split into two steps: one for the sequential behaviour and one for the concurrency control. This new mechanism together with my event model solves many problems of the wellknown inheritance anomalies. 1 INTRODUCTION In concurrent object-oriented environments objects can be accessed concurrently by multiple threads of control. A concurrent programming language has to provide means for pre...
Cited by 0
Martin Henz Martin, Martin Muller, Markus Wolf · 1995
Multi-user dungeons (MUDs) are textbased computer games being played over the Internet. They are usually based on a simple clientserver architecture, allowing for their wide availability, but also imposing serious limitations upon their users. In this paper, we propose an implementation of a MUD as a truly distributed application using the concurrent object-oriented programming language Oz to overcome these limitations. Keywords--- Oz, multi-user dungeons, distributed programming 1. Introduction Distributed programming is gaining importance in today's globally networked computing. Concurrent objects allow real-world concurrency of distributed applications to be naturally modeled. Our research concentrates on the concurrent object-oriented programming language Oz [8]. Our aim is to explore the possibilities and limitations of the language for distributed applications through practical applications. In this paper, we focus on distributed multi-user games (MUDs). The term MUD original...
Cited by 0
George A. Papadopoulos · 1997
The relationship between the generalised computational model of Term Graph Rewriting Systems (TGRS) and Object-Oriented Programming (OOP) is explored and exploited by extending the TGRS model with records where access to parameters is done by naming rather than position. Records are then used as the basis for expressing object-oriented techniques such as object encapsulation and (various forms of) inheritance. The effect is that TGRS with records can now be used as an implementation model for a variety of (concurrent) object-oriented (functional, logic or otherwise) languages but also as a common formalism for comparing various related techniques (such as different forms of inheritance or approaches for providing solutions to problems caused by the combination of concurrency and interaction between objects). Keywords: Object-Oriented Programming; Concurency and Parallelism; Programming Language Extensions; Rewriting Systems. Object-Oriented Term Graph Rewriting George A. Papadopoulos...
Cited by 0
Constantinos Constantinides, Atef Bader, Tzilla Elrad · 1999
Although not bound to Object-Oriented Programming (OOP), Aspect-Oriented Programming (AOP) is a paradigm proposal that retains the advantages of OOP and aims at avoiding the tyranny of dominant decomposition. The goal is to achieve an improved separation of concerns in both design, and implementation. Our work concentrates on the aspectual decomposition of concurrent object-oriented systems. We address composition of concerns by the aspect moderator class that coordinates the interaction of components and aspects while preserving the semantics of the overall system. Our design framework provides an adaptable model that allows for an open language where new aspects (specifications) can be added and their semantics can be delivered to the compiler through the moderator. In essence the aspect moderator framework is a program that extends the language itself. Keywords: Aspect-Oriented Programming, Concurrent Programming, Open Implementation. 1. Introduction There are numerous benefits f...
Cited by 1
O. M. Nierstrasz · 1989
Hybrid is a strongly-typed, concurrent, object-oriented programming language in which objects are active entities. In this paper we provide an overview of the language constructs, paying particular attention to the mechanisms for programming concurrent applications, and we describe our experiences in developing a prototype implementation of the language and its run-time environment.
Cited by 0
Jayadev Misra · 1995
Object-based sequential programming has had a major impact on software engineering. However, object-based concurrent programming remains elusive as an effective programming tool. The class of applications that will be implemented on future high-bandwidth networks of processors will be significantly more ambitious than the current applications (which are mostly involved with transmissions of digital data and images), and object-based concurrent programming has the potential to simplify designs of such applications. Many of the programming concepts developed for databases, object-oriented programming and designs of reactive systems can be unified into a compact model of concurrent programs that can serve as the foundation for designing these future applications. We propose a model of multiprograms and a discipline of programming that addresses the issues of reasoning (e.g., understanding) and efficient implementation. The major point of departure is the disentanglement of sequential and multiprogramming features. We propose a sparse model of multiprograms that distinguishes these two forms of computations and allows their disciplined interactions.
Cited by 0
Raphael Collet, Peter Van Roy · 2001
The Oz programming model is a general computation model which encompasses most programming paradigms, namely logic programming, functional programming with higher-order, imperative programming with state, object-oriented programming, and concurrent programming. The paper introduces the model with few technical requirements. It then gives an abstract syntax of the language, and presents its operational semantics.
Cited by 0
Denis Caromel · ACM SIGPLAN OOPS Messenger · 1991
Concurrent object-oriented programming faces a dilemma: should a language provide an explicit or an implicit concurrency control? Both styles of programming present advantages and limitations.This article discusses this issue and proposes a solution: the programming of user-defined abstractions.We advocate that no framework of concurrency control is universal, but that many present interesting properties. The solution resides in the building of reusable libraries of concurrent abstractions.
Cited by 1Open access
Denis Caromel · 1991
Concurrent object-oriented programming faces a dilemma: should a language provide an explicit or an implicit concurrency control? Both styles of programming present advantages and limitations.This article discusses this issue and proposes a solution: the programming of user-defined abstractions.We advocate that no framework of concurrency control is universal, but that many present interesting properties. The solution resides in the building of reusable libraries of concurrent abstractions.
Cited by 4