Showing papers on "Concurrent object-oriented programming published in 1987"

Object-oriented concurrent programming

Abstract: This book presents papers on parallel processing. Topics considered include programming languages, distributed data processing, knowledge bases, concurrent programming using actors, modeling and programming in an object-oriented concurrent language, and concurrent strategy execution.

A VLSI Architecture for Concurrent Data Structures

Abstract: Concurrent data structures simplify the development of concurrent programs by encapsulating commonly used mechanisms for synchronization and communication into data structures. This thesis develops a notation for describing concurrent data structures, presents examples of concurrent data structures, and describes an architecture to support concurrent data structures. Concurrent Smalltalk (CST), a derivative of Smalltalk-80 with extensions for concurrency, is developed to describe concurrent data structures. CST allows the programmer to specify objects that are distributed over the nodes of a concurrent computer. These distributed objects have many constituent objects and thus can process many messages simultaneously. They are the foundation upon which concurrent data structures are built. The balanced cube is a concurrent data structure for ordered sets. The set is distributed by a balanced recursive partition that maps to the subcubes of a binary n-cube using a Gray code. A search algorithm, VW search, based on the distance properties of the Gray code, searches a balanced cube in O(logN) time. Because it does not have the root bottleneck that limits all tree-based data structures to O(1) concurrency, the balanced cube achieves O(N/logN) concurrency. Considering graphs as concurrent data structures, graph algorithms are presented for the shortest path problem, the max-flow problem, and graph partitioning. These algorithms introduce new synchronization techniques to achieve better performance than existing algorithms. A message-passing, concurrent architecture is developed that exploits the characteristics of VLSI technology to support concurrent data structures. Interconnection topologies are compared on the basis of dimension. It is shown that minimum latency is achieved with a very low dimensional network. A deadlock-free routing strategy is developed for this class of networks, and a prototype VLSI chip implementing this strategy is described. A message-driven processor complements the network by responding to messages with a very low latency. The processor directly executes messages, eliminating a level of interpretation. To take advantage of the performance offered by specialization while at the same time retaining flexibility, processing elements can be specialized to operate on a single class of objects. These object experts accelerate the performance of all applications using this class.

Concurrent PROLOG: Collected Papers

Abstract: From the Publisher: Concurrent Prolog brings together for the first time descriptions of the major concurrent logic programming languages proposed so far for future parallel computer systems. In particular, it describes the concurrent logic programming language Flat Concurrent Prolog, a comprehensive and radical approach to parallel computing that is based on a simple foundation. After surveying recent research in concurrent logic programming languages, these two volumes address all of the relevant aspects of constructing such a parallel computer system. They investigate how systems programming and the implementation of parallel algorithms can be carried out with this language; how advanced program development techniques can be applied; how to embed other high-level languages in it; and how to implement this language efficiently on sequential and parallel computers. The results of these investigations suggest that Flat Concurrent Prolog can serve as a general-purpose high-level machine language for parallel computers. Ehud Y. Shapiro is Senior Scientist, Department of Applied Mathematics, Weizmann Institute of Science. Concurrent Prolog is included in his Logic Programming series. Much of the research describe in the book was stimulated by the Fifth Generation project and cross-fertilization between the authors and ICOT.

Concurrent object-oriented programming in Act 1

Abstract: To realize this, we propose a model of computation based on the notion of actors, active objects that communicate by message passing. Actors blur the conventional distinction between data and procedures. For parallel computation, actors called futures create concurrency, by dynamically allocating processing resources. Serializers restrict concurrency by constraining the order in which events take place, and have changeable local state. The actor philosophy is illustrated by a description of our prototype actor interpreter Act 1. 1. Actors meet the requirements for organizing programs as societies What capabilities are needed in a computational model to construct models of intelligent processes as a society of cooperating individuals? First, knowledge must be distributed among the members of the society, not centralized in a global data base. Each member of the society should have only the knowledge appropriate to his (or her) own functioning. We shall show how Act I distributes knowledge entirely in individual actors. Each actor has only the knowledge and expertise required for him to respond to messages from other actors. There's no notion of global state in an actor system. In a society model, each member should be able to communicate with other members of the society, to ask for help and inform others of his progress. In Act 1, all communication and interaction between actors uses message passing. No actor can be operated upon, looked at, taken apart or modified except by sending a request to the actor to perform the operation himself.

Experience and evolution of concurrent Smalltalk

Abstract: ConcurrentSmalltalk is an object-oriented concurrent programming language/system which has been running since late 1985. ConcurrentSmalltalk has the following features: Upper-compatibility with Smalltalk-80.Asynchronous method calls and CBox objects yield concurrency.Atomic objects have the property of running one at a time so that it can serialize the many requests sent to it.Through experience in writing programs, some disadvantages have become apparent related to concurrency control and the behavior of a block context. In this paper, these issues are re-examined in detail, and then the evolution of the solutions for overcoming these shortcomings is described along with the model of computation in ConcurrentSmalltalk. New features are explained with an example program. The implementation of the ConcurrentSmalltalk virtual machine is also presented along with the evaluation of it.

Inheritance and synchronization in concurrent OOP

Abstract: This paper discusses knowledge sharing (inheritance) mechanisms for Object-Oriented Programming (OOP) in the context of concurrent (distributed) languages. We review three different schemes: inheritance, delegation and copy. A fourth model, called recipe-query, is presented and all are compared and criticized. Techniques relying on the shared memory assumption are rejected. We point out the conflict between distributing knowledge among objects and the synchronization of concurrent objects.

What is “object-oriented programming”?

Abstract: "Object-Oriented Programming" and "Data Abstraction" have become very common terms. Unfortunately, few people agree on what they mean. I will offer informal definitions that appear to make sense in the context of languages like Ada, C++, Modula-2, Simula67, and Smalltalk. The general idea is to equate "support for data abstraction" with the ability to define and use new types and equate "support for object-oriented programming" with the ability to express type hierarchies. Features necessary to support these programming styles in a general purpose programming language will be discussed. The presentation centers around C++ but is not limited to facilities provided by that language.

Functional programming for concurrent and distributed computing

Abstract: There are at least two approaches to the design of languages for parallel computing. One approach is to use functional or relational languages which are easy to read, write, transform and verify. The more conventional approach is to use procedural languages which give a programmer a high degree of control over the run-time behaviour of a program. There is a need to reconcile these two approaches in a language which permits both simplicity and efficiency.

Extending logic programming to object programming: the system lap

Abstract: Object oriented programming aims at code lisibility and conciseness via abstract data type declarations and takes advantage from setting the objects (ie data) in the center of the application, instead of procedures or demonstrations. Just as in Logic programming, where describing the properties of the solution of some problem is (theoreticaly) enough to allow the program to compute the solution, Object programming proceeds from the fact that purely declarative information leads to more procedural behaviour. It appears that Logic programming and Object programming are complementary in the sense that the first is very suitable for expressing subtle reasoning, but rather weak as a formalism for describing complex structures, and conversely for the second. These considerations led us, at the IIRIAM, to combine Logic and Object programming in order to use the advantages of both. Our research effort resulted In the system LAP, an extension of Prolog to object programming, giving a new dimension to the latter, through logic programming concepts: processing of partially known data and non determinism applied at the object level. The first part of this paper introduces the main characteristics of LAP, faced with the requirements of AI application development. The second part illustrates some of these capabilities through simple examples.

Concurrency control based on distributed cycle detection

Abstract: This paper presents a novel optimistic concurrency control mechanism for distributed database systems. The optimistic concurrency control mechanism is based on a distributed algorithm for cycle detection which determines whether a transaction violates serializability or not. There are three advantages of this concurrency control mechanism. (1) It certifies execution of transactions in a distributed fashion and in parallel. (2) Local concurrency control is performed at each site independently. Global concurrency control verifies consistency of local concurrency control only when a transaction intends to commit. The separation of local and global concurrency controls enables us to integrate different local concurrency control mechanisms such as two-phase locking and timestamping into a single concurrency control mechanism. This is suitable for concurrency control in heterogeneous database systems. (3) No assumption is made on how data are distributed. It works in partially replicated database systems as well as in partitioned or fully replicated database systems.

A conceptual programming environment

Abstract: Conceptual programming means having programmers work directly with their models of how their system is put together. It means providing them with the means for designing, coding and maintaining systems on a computer using the pictures and text they normally use on paper. An environment for conceptual programming requires flexibility to support a wide range of languages and graphics to support languages based on pictures. The GARDEN system is a prototype conceptual programming environment that uses an object-oriented framework to meet these requirements.

Ecoop 87: European Conference on Object-Oriented Programming

Abstract: Deltatalk: An Empirically and Aesthetically Motivated Simplification of the Smalltalk-80 Language.- Reversible Object-Oriented Interpreters.- Using Types and Inheritance in Object-Oriented Languages.- Inheritance and Synchronization in Concurrent OOP.- On Including Part Hierarchies in Object-Oriented Languages, with an Implementation in Smalltalk.- What is "Object-Oriented Programming"?.- Object Representation of Scope During Translation.- Dynamic Grouping in an Object-Oriented Virtual Memory Hierarchy.- Traveler: The Apiary Observatory.- Classification of actions or Inheritance also for methods.- Semantics of Smalltalk-80.- The Construction of User Interfaces and the Object Paradigm.- The ZOO Metasystem: A Direct-Manipulation Interface to Object-Oriented Knowledge Bases.- The Filter Browser Defining Interfaces Graphically.- The Common Lisp Object System: An Overview.- Concurrency Features for the Trellis/Owl Language.- Objects as Communicating Prolog Units.- An Object Modeling Technique for Conceptual Design.- A Modeller's Workbench: Experiments in Object-Oriented Simulation Programming.- Behavioral Simulation Based on Knowledge Objects.- Conformance, Genericity, Inheritance and Enhancement.- Inheritance and Subtyping in a Parallel Object-Oriented Language.- On Some Algorithms for Multiple Inheritance in Object Oriented Programming.- FORK: A System for Object- and Rule-Oriented Programming.- Overview of a Parallel Object-Oriented Language CLIX.

The Formes system: a musical application of object-oriented concurrent programming

Abstract: o musical representation and used to drive a general sound synthesizer. We first focus on the riginal concepts induced by musical applications. Object-Oriented Programming matches a d t subset of the numerous requirements of Computer Music Composition, but we need to exten his metaphor towards the time component in order to describe and control the temporal t s structures of music. Therefore we introduce the monitor concept which supports differen chedulings of hierarchical processes, and extends the class concept to the field of concurrent

Persistent programming and secure data storage

Abstract: The persistent programming style supports secure object based computation. It is argued that persistent programming provides a superior model for the support of a number of programming areas. A proposed standard for persistent programming systems is presented which provide support for data security at several levels: within process, interprocess interoperating system and inter computer. Primitives to support data integrity at each level are presented. Estimates are given of the effective bandwidth of covert channels.

Concurrent programming in Modula-2

Abstract: This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.This paper describes a concurrent process manager that has been developed for the Modula-2 programming language. Using this software, students can gain practical experience in designing and implementing concurrent programs using processes, semaphores, and message links. The use of abstraction in describing the process manager is advocated, and a variety of concurrent programming exercises are presented.

ARCTIC - Programmer's Manual and Tutorial.

Abstract: : ARCTIC is a programming language for describing real-time systems with many concurrent activities. Unlike conventional languages that model concurrency as multiple sequential threads of control, ARCTIC models concurrency as multiple functions of time, whose domains may overlap. This radical departure from convention has many advantages, including a declarative programming style, implicit synchronization, convenient specification of timing relationships, and an integrated approach to event-driven and data-driven real-time computation. This document is a specification of the ARCTIC language. Examples have been included in the hope that this specification may be also used as a tutorial. Details of a preliminary implementation of ARCTIC are given in the appendix.

A comparison of concurrent languages: a class project

Abstract: This paper describes a class project for a graduate level course in systems programming which emphasizes concurrency issues.

An example case study on Ada tasking

Abstract: Case studies are an important method for teaching complex aspects of a programming language. This is especially true for real-time/concurrent systems. This paper presents a software requirements specification for a small but realistic real-time system, and then presents the solution in Ada. The actual hardware interactions are abstracted out, allowing the solution to be developed on a multi-user system. The focus of the solution is on treatment of certain aspects of concurrency. The solution model is based on a paradigm of top-level design, detailed design, and code.