Paulo Henrique Monteiro Borba · 1995
FOOPS is a concurrent object oriented specification language with an executable subset. In this thesis we propose an extension of FOOPS with features for specifying systems of distributed and autonomous objects. This extension supports most features of concurrent object oriented programming, including classes of objects with associated methods and attributes, object identity, dynamic object creation and deletion, overloading, polymorphism, inheritance with overriding, dynamic binding, concurrency, nondeterminism, atomic execution, evaluation of method expressions as background processes, and object protection. The main contribution of this thesis is to develop a framework for supporting formal development of software in the extension of FOOPS mentioned above. In particular, we introduce a structural operational semantics for FOOPS, a notion of refinement for concurrent object oriented programs, congruence properties of refinement of FOOPS programs, and tools for mechanizing refinement...
Cited by 0
1991
Widespread acceptance of concurrent object-oriented programming in the field can only be expected if smooth integration with sequential programming is achieved. This means that a common language base has to be used, where the concurrent syntax differs as little as possible from the sequential one but is associated with a "natural " concurrent semantics that makes library support for concurrency superfluous. In addition, not only should sequential classes be reusable in a concurrent context, but concurrent classes should also be reusable in a sequential context. It is suggested that concurrency annotations be inserted into otherwise sequential code. They are ignored by a sequential compiler, but a compiler for the extended concurrent language will recognize them and generate the appropriate concurrent code. The concurrent version of the language supports active and concurrent objects and favours a declarative approach to synchronization and locking which solves typical concurrency problems in an easier and more readable way than previous ap-proaches. Concurrency annotations are introduced using Eiffel as the sequential base. Key words Concurrent object-oriented programming, reusable concurrent code, concurrency annotations, Eiffel, CEiffel
Cited by 0
Patricio Letelier, Isidro Ramos · 2007
OASIS is a Language for the Specification of Object Oriented Conceptual Models. In OASIS the conceptual schema of an information system is represented as a society of concurrent objects interacting with one another. Animation of such models in order to validate the Specification of Information Systems is an interesting topic. We have developed a basic Execution Model for OASIS Specifications. The Model includes features such as the representation of attributes, events, derivations, preconditions, evaluations and triggers. On the other hand, Concurrent Logic Programming is a suitable paradigm for distributed computation because it allows a natural representation of concurrence. Using Concurrent Logic Programming we are able to animate OASIS Specifications according to the OASIS Execution Model. In this work we show how the object-oriented (OO) concepts of an OASIS Specification are represented directly using Concurrent Logic Programming concepts. We give an example of a bank account cod...
Cited by 0
George A. Papadopoulos · 1998
We propose the development of multimedia programming frameworks based on the declarative logic programming setting and in particular the framework of object-oriented timed concurrent constraint programming (OO-TCCP). The real-time extensions that have been proposed for the concurrent constraint programming framework are coupled with the object-oriented and inheritance mechanisms that have been developed for logic programs yielding an integrated declarative environment for multimedia objects modelling, composition and synchronisation. The expressiveness and ability of OO-TCCP to act as a basis for building high-level, user-friendly authoring environments is illustrated by presenting a simple object model for multimedia composition and synchronisation followed by an analysis on how it can be used to model the temporal behaviour and relationships of multimedia objects. We then define a “universal ” set of multimedia programming primitives and we show how they can be implemented in OO-TCCP. Finally, we argue about the benefits of our approach wrt both easiness of programming and implementation of the proposed framework. To the best of our knowledge this is the first time logic programming (in the form of concurrent constraint — 1 — A Multimedia Programming Model Based on TCCP George A. Papadopoulos programming or otherwise) is used as a basis for designing and implementing multimedia programming frameworks.
Cited by 0
Sahand Shamal Taher · 2017
Encore is an object-oriented programming language which uses the acto rmodel as its concurrency model, and is specifically aimed atimplementing concurrent and parallel systems. Communication betwee ...
Cited by 0
Patrice Gagnon, Farid Mokhati, Mourad Badri · The Journal of Object Technology · 2008
We present, in this paper, a framework supporting a formal verification of concurrent UML models using the Maude language. We consider both static and dynamic features of concurrent object-oriented systems. We focus on UML class, state and communication diagrams. The formal and object-oriented language Maude, based on rewriting logic, supports formal specification and programming of concurrent systems, as well as model checking. The major motivations of this work are: (1) translating concurrent UML diagrams into a Maude formal specification and (2) applying model checking to the generated specifications. The approach is illustrated using a concrete case study.
Cited by 26Open access
Titiwoot Tongyoo, V. Chutchavong, O. Sangaroon · 2006 SICE-ICASE International Joint Conference · 2006
Threads class is represented as object the oriented design in programming languages. The multi-threaded execution collides from the same data access. This problem is fixed by synchronization critical section method in every thread, when the process is finished its behavior of terminated time of multithreading. Another problem arises due to threads class does not concurrent terminate execution. This paper also presents an object-oriented design using message control to solve concurrent terminated execution problem. By using a concept that every thread can be communicate to the center of object class. The main object decides to handle on every thread with stability executions. The benefit of handle during run time is broken and continue execute of threads. Using Delphi programming carries out an experimental result
Cited by 1
Denis Caromel · 1990
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 0
Takuo Watanabe, Akinori Yonezawa · 1988
Our work is along the line of the work of B. Smith and P. Maes. We first discuss our notion of reflection in object-oriented concurrent computation and then present a reflective object-oriented concurrent language ABCL/R. We give several illustrative examples of reflective programming such as (1) dynamic concurrent acquisition of “methods” from other objects, (2) monitoring the behavior of concurrently running objects, and (3) augmentation of the time warp mechanism to a concurrent system. Also the definition of a meta-circular interpreter of this language is given as the definition of a meta-object. The language ABCL/R has been implemented. All the examples given in this paper are running on our ABCL/R system.
Cited by 190
David Holmes, James Noble, John Potter · 1998
The integration of concurrency and object-oriented programming has been a goal of researchers for over a decade. To date, attempts to address reuse conflicts, known as "inheritance anomalies", have been limited in applicability and have not addressed all the issues that synchronisation raises. In this paper we take a detailed look at synchronisation by investigating five different aspects which must be considered. We investigate the different forms of the inheritance anomaly which can arise and look at how they can be avoided, either through the use of specific features of concurrent object-oriented languages, or common techniques of object-oriented programming. Finally we present a set of requirements for a concurrent object-oriented language to support a flexible concurrency model with an emphasis on the reuse of both synchronisation and functional code. 1. Introduction Objects and concurrency started off together back in the late sixties with Simula [Dah70], but they tended to go ...
Cited by 1
Sérgio Soares, Paulo Borba, Ricardo Lima · Proceedings - International Computer Software & Applications Conference · 2007
Concurrent programs are essential in the development of web based information systems. The wide dissemination of these systems increased the need for methods to create correct and efficient concurrent programs, which are usually difficult to implement and test. This paper presents guidelines to improve the concurrent control structure of object-oriented software using aspect-oriented programming through AspectJ based on an existent object-oriented concurrency control implementation method. We have defined a simple aspect framework that can be extended to implement concurrency control in applications complying with a software architecture presented in this paper. The framework comprises a set of reusable aspects useful for modularizing concurrency control.
Cited by 1
Benjamin Morandia, Sebastian Nanza, Bertrand Meyera · 2013
To support developers in writing reliable and efficient concurrent programs, novel concurrent 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 performance analyzer that is based on new metrics for programs written in SCOOP, an object-oriented programming model for concurrency. We discuss how the metrics can be used to discover performance issues, and we use the tool to optimize a concurrent robotic control software.
Cited by 1
Keith Clark, T. I. Wang · 1996
This paper introduces a distributed object oriented logic programming language, DK Parlog, in which each object, in addition to the normal procedural methods for accessing and updating state components, also has knowledge methods in the form of Prolog rules. The language is an OO extension of a distributed, multi-threaded, logic programming system. Encapsulation is by class definitions linked via single inheritance. Procedural method invocation is via asynchronous message send to the unique object identifier. Knowledge method invocation is via synchronous remote procedure call. Classes are also objects - they have their own state components and methods. An application in D Parlog consists of a collection of concurrently executing objects (classes and instances) distributed over a local area network.
The knowledge methods can be public or private, and can be dynamically modified by the procedural methods of the object using Prolog style knowledge base manipulation primitives. The dynamic knowledge of an object can be used as a declarative representation of part of its state.
This paper assumes some familiarity with concepts of concurrent object oriented programming and logic programming, ideally concurrent logic programming, but familiarity with Prolog will probably suffice.
Cited by 0
Sverker Janson · 1994
This thesis reports on an investigation into principles for combining the constraint solving and don't know nondeterministic capabilities of Prolog and the constraint logic programming languages with the process-describing capabilities of concurrent logic languages such as GHC. The result, AKL, is a coherent language supporting multiple programming paradigms, such as concurrent, object-oriented, functional, logic, and constraint programming. In addition, AKL offers a large potential for automatic parallel execution.
Cited by 0
Carlos Augusto Da Silva Cunha, Dissertação De Mestrado Em Informática, Braga Setembro · 2006
É autorizada a reprodução integral desta dissertação, apenas para efeitos de investigação, mediante declaração escrita do interessado, que a tal se compromete. Concurrent programming is more complex than sequential programming, which requires from programmers an additional effort to manage such increase of complexity in software. Concurrency requires the specification of actions that can occur simultaneously and the prevention of undesirable interactions between these concurrent actions. The lack of suitable software abstractions to specify concurrent behaviour makes concurrent software harder to develop and maintain as well as reduces their reuse potential. Several high level concurrency constructs have been proposed in the last fifteen years in Concurrent Object Oriented Languages (COOLs). These constructs can help to structure concurrent programs to manage this increase in complexity. However, current mainstream object oriented languages, such as Java or C#, do not include many of these high level abstractions. More recently, some of these constructs were revisited as a set of patterns, which represent recurring solutions to frequently occurring concurrency problems.
Cited by 0
Mordechai Ben‐Ari · 1996
The Ada programming language is an excellent vehicle for teaching concurrent programming because support for concurrency has been designed into the language. The paper shows how primitives from other concurrent programming languages (occam, Linda, Joyce) can be simulated within Ada. This enables students to study other constructs without the overhead of learning a new language and programming environment. The simulations use inheritance which was introduced into the new Ada 95 standard. They can also be used as examples of inheritance when teaching object-oriented programming.
Cited by 8
2009
Abstract. The design of large and complex distributed systems requires a modular approach to support reuse and verification. We propose an object-oriented programming model based on concurrently executing communicating agents (concurrent objects) and an associated proof methodology that exploits the class hierarchy to allow for modular verification. We propose to separate protocol from functionality in class definitions, and advocate separate hierarchies of protocol classes as a way to overcome the inheritance anomaly of concurrent object-oriented programming. We formalize an agent in Lamport's Temporal Logic of Actions. Modular verification is achieved by restricting inheritance in a way that ensures that subclasses refine superclasses. Interesting properties can thus be verified at an abstract level, ignoring unnecessary implementation detail. 1 Introduction The object-oriented paradigm in software construction promises modular, incremental design and has therefore become very attractive to practitioners. On the other hand, its semantical foundations are still not well-understood, and few formalisms [3, 10] have been defined that allow the verification of object-oriented programs. In particular, it is notoriously hard to exploit the modular structure of object (or class) definitions in reasoning about object-oriented systems.
Cited by 0
David Holmes · 1999
oncurrent programming, and even concurrent objects, is vast. Lea [Lea99] provides comprehensive, annotated lists of further readings throughout his book, covering the many different facets of concurrent programming, parallel programming, concurrent object systems and other related areas. Andrews [And91] is a good text on the general issues of systems level concurrent programming, as are [Ben82] and [Ben90], whilst operating systems texts such as [Tan92] and [Sil94] introduce the concepts from an OS perspective. Multi-threading texts are usually based around the usage of particular libraries or interfaces, such as those defined by Unix International (UI) and POSIX. Kleiman et al [Kle96] provides a good account of multi-threaded programming with UI threads in Sun's Solaris Extract from the Ph.D. Thesis: "Synchronisation Rings: Composable Synchronisation for Object-Oriented Systems" by David Holmes, Department of Computing, Macquarie University, Sydney h
Cited by 0
Thilo Kielmann · 1993
In this paper, we introduce object--oriented programs as sets of communicating objects. We investigate possibilities for their concurrent execution, starting with a review of existing concurrent, object--oriented systems. Most of these systems introduce new programming--language features, forcing a programmer to control concurrency by hand. In contrast, we prefer automatic parallelization of programs. For this purpose, we introduce a concurrent, object--based execution model. 1 Introduction The aim of this work is to take programs written in an object--oriented language and execute them in parallel on a set of processors. The object--oriented language will thus play the role of an "executable specification" without any implication of an execution mode (sequential or parallel). As it is widely accepted, significant improvements of computing power will, in the near future, only be achieved by the use of multi--processor architectures in which numerous processing elements share the app...
Cited by 0
Oscar Nierstrasz · Medical Entomology and Zoology · 1993
Keynote Address (Abstract).- Intimate Computing and the Memory Prosthesis: A Challenge for Computer Systems Research?.- Frameworks and Reuse.- Active Programming Strategies in Reuse.- Frameworks in the Financial Engineering Domain An Experience Report.- Integrating Independently-Developed Components in Object-Oriented Languages.- Concurrency and Distribution I.- Encapsulating Plurality.- Object Oriented Interoperability.- Implementation of Distributed Trellis.- Types & Subtypes.- A New Definition of the Subtype Relation.- Attaching Second-Order Types to Methods in an Object-Oriented Language.- Typed Sets as a Basis for Object-Oriented Database Schemas.- Invited Talk.- The OSI Managed-object Model.- Languages and Inheritance.- Nested Mixin-Methods in Agora.- Solving the Inheritance Anomaly in Concurrent Object-Oriented Programming.- Type Inference of Self.- Time-Dependent Behaviour.- Predicate Classes.- TOOA: A Temporal Object-Oriented Algebra.- A Timed Calculus for Distributed Objects with Clocks.- Concurrency and Distribution II.- A Language Framework for Multi-Object Coordination.- Panda - Supporting Distributed Programming in C++.- Transparent parallelisation through reuse: between a compiler and a library approach.- OO Analysis and Design.- Design Patterns: Abstraction and Reuse of Object-Oriented Design.- ObjChart: Tangible Specification of Reactive Object Behavior.- O-O Requirements Analysis: an Agent Perspective.- Reflection.- Designing an Extensible Distributed Language with a Meta-Level Architecture.- MetaFlex: A Flexible Metaclass Generator.- Panel Discussion (Position Statements).- Panel: Aims, Means, and Futures of Object-Oriented Languages.
Cited by 0