59,227 research outputs found
An Implementation of the Object-Oriented Concurrent Programming Language SINA
SINA is an object-oriented language for distributed and concurrent programming. The primary focus of this paper is on the object-oriented concurrent programming mechanisms of SINA and their implementation. This paper presents the SINA constructs for concurrent programming and inter-object communication, some illustrative examples and a message-based implementation model for SINA that we have used in our current implementation
Composing concurrent objects
Adopting the object-oriented paradigm for the development of large and complex software systems offers several advantages, of which increased extensibility and reusability are the most prominent ones. The object-oriented model is also quite suitable for modelling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. In addition, very little attention has been paid by the conventional object-oriented development methodologies to the analysis and design of\ud
synchronisation constraints for concurrent objects.\ud
To address these problems, in this thesis the framework of composition-filters, an extension to the object-oriented model, is adopted. An analysis is presented of the problems involved in reusing and extending concurrent objects, in particular the so-called inheritance anomalies. Based on this analysis, a set of criteria for effective extensible concurrent objectoriented\ud
programming languages is formulated.\ud
The thesis introduces techniques for the creation of concurrency and the synchronisation of concurrent activities, fully integrated within the (object-oriented) composition-filters model. Important properties of the proposed object model are: all objects are -potentially- active, intra-object concurrency is supported and synchronisation specifications are fully separated\ud
from method implementations. The applicability and expressive power of the proposed technique are demonstrated, and it is shown how reusability and extensibility of concurrent objects are achieved
The Oz programming model
The Oz Programming Model (OPM) is a concurrent programming model subsuming higher-order functional and object-oriented programming as facets of a general model. This is particularly interesting for concurrent object-oriented programming, for which no comprehensive formal model existed until now. The model can be extended so that it can express encapsulated problem solvers generalizing the problem solving capabilities of constraint logic programming. OPM has been developed together with a concomitant programming language Oz, which is designed for applications that require complex symbolic computations, organization into multiple agents, and soft real-time control. An efficient, robust, and interactive implementation of Oz is freely available
Object-Oriented Programming Language Facilities for Concurrency Control
Concurrent object-oriented programming systems require support for concurrency control, to enforce consistent commitment of changes and to support program-initiated rollback after application-specific failures. We have explored three different concurrency control models -- atomic blocks, serializable transactions, and commit-serializable transactions -- as part of the MELD programming language. We present our designs, discuss certain programming problems and implementation issues, and compare our work on MELD to other concurrent object-based systems
Integrating Object-Oriented Programming and Protected Objects in Ada 95
Integrating concurrent and object-oriented programming as been an active research topic since the late 1980s. There is now a plethora of methods for achieving this integration. The majority of approaches have taken a sequential object-oriented language and made it concurrent. A few approaches have taken a concurrent language and made it object-oriented. The most important of this latter case is the Ada 95 language which is an extension to the object-based concurrent programming language Ada 83. Arguably, Ada 95 does not fully integrate its models of concurrency and object-oriented programming. For example. neither tasks nor protected objects are extensible. This paper discusses ways in which protected objects can be made more extensible
Concurrent object-oriented programming: The MP-Eiffel approach
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)
Channels as Objects in Concurrent Object-Oriented Programming
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.Comment: In Proceedings PLACES 2010, arXiv:1110.385
Distributed Reliable Object-Oriented Programming (DROOP)
The Simple Object-Oriented Concurrent Programming (SCOOP) model proposed by Bertrand Meyer and illustrated through the Eiffel programming language is a simple yet powerful model for concurrent programming. In this paper, we analyze the applicability of the SCOOP model to physically distributed systems manifesting transient and permanent failures. We suggest additions to the basic SCOOP model in order to cope with such failures, coining the term Distributed Reliable Object-Oriented Programming (DROOP)
- …