The development of concurrent object-based programmig languages has suffered from the lack of any generally accepted formal foun ion for de finn their semantics. Furthermore, the delicate relation p between object-oriented features supportin reuse an operation features con n g in teraction a n state chan is poorlyun rstood in a con urren t settin To address this problem, we propose the developmen t of an object calculus, borrowi n heavily from relevan t work in the area of process calculi. To this en we briefly review some of this work, we pose some i ormal requiremen ts for an object calculus, an we present the syntax, operation seman tics an use through examples of a proposed object calculus, called OC.

Object-oriented programming hasn't created a viable software component industry. From a technical perspective, the reason for this failure lies in an insufficient consideration of the unique requirements of component software. Object-oriented programming too often concentrates on individual objects, instead of whole collections of objects, i.e., components. Component-oriented programming requires more stringent information hiding, a more dynamic approach, and better safety properties than object-oriented programming. Keywords: component-oriented programming, dynamic languages, component software industry, object models, fragile base class problem 1. Introduction The existence of a software crisis has been recognized as early as 1968 [NR 69]. It became clear that to overcome this crisis, software construction would need to be treated as a genuine engineering discipline. In a mature engineering discipline, new products are rarely developed from scratch. Instead, products are composed o...

We present a graphical environment for parallel object-oriented programming. It provides visual tools to develop and debug object-oriented programs as well as parallel or concurrent systems. This environment was derived from a structural operational semantics of an extension of the Eiffel language, Eiffel//. Object-related features of the language (inheritance, polymorphism) are formalized using a big-step semantics, while the interleaving model of concurrency is expressed with small-step semantics. Without user instrumentation, the interactive environment proposes features such as step-by-step animated executions, graphical visualization of object and process topology, futures and pending requests, control of interleaving, deadlock detection.

Divide--and--conquer algorithms obtain the solution to a given problem by dividing it into subproblems, solving these recursively and combining their solutions. In this paper we present a system that automatically transforms sequential divide--and--conquer algorithms written in the C programming language into parallel code which is then executed on message--passing multicomputers. The user of the system is expected to add only a few annotations to an existing sequential program. The strategies required for transforming sequential source code to executable binaries are discussed. The performance speedups attainable will be illustrated by several examples. Keywords: divide--and--conquer algorithms, automatic parallelization, parallelizing compilers, message-- passing multicomputers, transputer systems, workstation clusters Abbreviated title: Parallelization of Divide--and--Conquer Algorithms 1 Introduction The generation of efficient parallel code for message--passing multicomputer s...

This paper describes design and implementation issues for introducing concurrency to object-oriented programming. Designing a concurrency class library along with an object-oriented concurrent program design method is presented as the prefered way to extend an existing objectoriented language. A set of classes designed to facilitate concurrent programming using the sequential objectoriented language EIFFEL is proposed without modifying or extending the language or its runtime system.. The main concurrency abstractions provided by the approach are: objects as processes -- active objects -- and asynchronous remote method invocation with data-driven synchronization. 1 Introduction Object-oriented paradigm appears to be wellsuited for concurrent programming. Objects can be used to implement not only data-structures but also processes that are objects with a protected internal state and a prescribed behavior. Unifying the notion of object with the notion of process provides the bridge to...

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.

We investigate the use of a TLA specification for modeling and proving parallelization within an object-oriented language. Our model is based on Eiffel// a parallel extension of Eiffel, where sequential programs can be reused for parallel or concurrent programming with very minor changes. We want to prove that both versions of a given program (sequential and parallel) are equivalent with respect to some properties. This article presents a description in TLA+ that captures the general Eiffel// execution model, and, as a case-study, specifies a program (a binary search tree) in both its sequential and parallel form. We then prove a property that demonstrates a behavioral equivalence for the two versions.

Featuring a small set of concepts (e.g. systematic asynchronous communications, polymorphism between passive and active objects, wait-by-necessity) the Eiffel// model allows for the derivation of parallel systems from sequential ones. Based on a formal semantics of that model, this article expresses and formally proves language properties such as the absence of shared objects, the sequentiality of subsystems. Moreover, equivalence of programs, sequential vs. parallel, can also be demonstrated in some cases. This work is a first step towards automatic (or semiautomatic) parallelization of object-oriented programs.

Abstract not found