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

Aspect-oriented programming

Abstract: The performance of relational database applications often suffers. The reason is that query optimizers require accurate statistics about data in the database in order to provide optimal query execution plans. Unfortunately, the computation of these statistics must be initiated explicitly (e.g., within application code), and computing statistics takes some time. Moreover, it is not easy to decide when to update statistics of what tables in an application. A well-engineered solution requires adding source code usually in many places of an application. The issue of updating the statistics for database optimization is a crosscutting concern. Thus we propose to use aspect-orientation to automate the calculation. We show how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries. Due to the automatic nature, computation takes place on time for complex queries, only when necessary, and only for stale tables. The implementation language for the automated aspect-oriented statistics update concern is AspectJ, a well known and mature aspect-oriented programming language. The approach can however be implemented in any other aspect-oriented language. Unlike in traditional object-oriented pattern solutions, e.g. using the interceptor pattern, we do not have to modify existing code.

Active object: an object behavioral pattern for concurrent programming

Abstract: This paper describes the Active Object pattern, which decouples method execution from method invocation in order to simplify synchronized access to an object that resides in its own thread of control. The Active Object pattern allows one or more independent threads of execution to interleave their access to data modeled as a single object. A broad class of producer/consumer and reader/writer applications are wellsuited to this model of concurrency. This pattern is commonly used in distributed systems requiring multi-threaded servers. In addition, client applications, such as windowing systems and network browsers, employ active objects to simplify concurrent, asynchronous network operations.

The Oz Programming Model

Abstract: 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.

An Introduction to Programming with Threads

Abstract: This paper provides an introduction to writing concurrent programs with “threads”. A threads facility allows you to write programs with multiple simultaneous points of execution, synchronizing through shared memory. The paper describes the basic thread and synchronization primitives, then for each primitive provides a tutorial on how to use it. The tutorial sections provide advice on the best ways to use the primitives, give warnings about what can go wrong and offer hints about how to avoid these pitfalls. The paper is aimed at experienced programmers who want to acquire practical expertise in writing concurrent programs.

Interaction categories and the foundations of typed concurrent programming

Abstract: We propose Interaction Categories as a new paradigm for the semantics of functional and concurrent computation. Interaction categories have speciications as objects , processes as morphisms, and interaction as composition. We introduce two key examples of interaction categories for concurrent computation and indicate how a general axiomatisation can be developed. The upshot of our approach is that traditional process calculus is reconstituted in functorial form, and integrated with type theory and functional programming. A second contribution of the paper is to propose a way of combining the Propositions-as-Types and Veriication paradigms based on the notion of Speciication Structure. We describe speciication structures for liveness properties and deadlock-freedom, and illustrate our ideas using a standard example from concurrency theory.

The first programming paradigm and language dilemma

Abstract: In recent years there has been increasing controversy surrounding the choice of a language for introducing programming to computer science majors The issue has been complicated by the increasing acceptance of the importance of non-procedural paradigms This paper compares the available vehicles for teaching programming to beginners These comparisons are based on the results of a survey conducted by the authors in early 1995 and on the published reports and opinions of other workers in this area

A Software Environment for Concurrent Coordinated Programming

Abstract: In this paper, we present ConCoord: a software environment for Concurrent Coordinated programming. ConCoord contributes to concurrent programming in three ways. First, it separates programming into computation and coordination in order to reduce programming complexity. A ConCoord program is a dynamic collection of processes for either computation or coordination. Computation processes encapsulate conventional sequential computations. Coordination processes manage concurrency and only this. They handle dynamic evolution of the program structure depending on conditions on the program structure and execution state of processes. Second, ConCoord is targeted at networks of sequential and parallel machines. These networks support efficiently the exploitation of a diversity of concurrency grains on their different architectures. In order to take advantage of this feature, ConCoord provides linguistic support for heterogeneous concurrency exploitation. Third, reuse has being a primary concern in ConCoord's design. In our environment, sequential algorithms can be reused within computation processes. Concurrency management of concurrent algorithms can be reused within coordination processes. Both computation and coordination processes can be specified as parameterised reusable software components.

ICC++—a C++ dialect for high performance parallel computing

Abstract: ICC++ is a new concurrent C++ dialect which supports a single source code for sequential and parallel program versions, the construction of concurrent data abstractions, convenient expression of irregular and fine-grained concurrency, and high performance implementation. ICC++ programs are annotated with potential concurrency, facilitating both sharing source with sequential programs and automatic grain size tuning for efficient execution. Concurrency control is at the object level; each object ensures the consistency of its own state. This consistency can be extended over larger data abstractions. Finally, ICC++ integrates arrays into the object system and the concurrency model. In short, ICC++ addresses concurrency and its relation to abstractions --- whether they are implemented by single objects, several objects, or object collections. The design of the language, its rationale, and where to find implementations are all described.

A Knowledge-Theoretic Semantics for Concurrent METATEM

Abstract: The aim of this paper is to develop a semantics for the multi-agent programming language Concurrent MetateM, by using the tools of knowledge theory. We begin by presenting an informal overview of the Concurrent MetateM language, and then formally define the notion of a Concurrent MetateM agent program, the possible states of a Concurrent MetateM agent and system, and finally, what constitutes an acceptable run of a Concurrent MetateM system. The various semantic constructs developed during this process are then used as the foundation upon which to construct a temporal logic of knowledge; we show that certain formulae of this logic correspond to properties of Concurrent MetateM systems. This correspondence can be used to systematically derive the theory of a Concurrent MetateM system. Reasoning about a Concurrent MetateM system then reduces to proving properties of the corresponding logical theory. We give some simple examples, to illustrate the process, and finally, speculate about future research directions. Comments on related work are also included.

MAP: mobile assistant programming for large scale communication networks

Abstract: We have defined a new network programming model called mobile assistant programming (MAP) for development and execution of communication applications in large scale networks of heterogeneous computers. MAP assistants are high-level interpreted programs that can move between nodes, create clones and report results, Their execution is asynchronous and persistent to allow client disconnections and survival of node failures. We have implemented the mobile assistant programming model using the World-Wide Web framework and the scheme programming language. Our initial experience shows that the MAP model is a useful paradigm for programming communication applications in large scale networks.

Models for Concurrent Constraint Programming

Abstract: Concurrent constraint programming is a simple but powerful frame-work for computation based on four basic computational ideas: concurrency (multiple agents are simultaneously active), communication (they interact via the monotonic accumulation of constraints on shared variables), coordination (the presence or absence of information can guard evolution of an agent), and localization (each agent has access to only a finite, though dynamically varying, number of variables, and can create new variables on the fly). Unlike other foundational models of concurrency such as CCS, CSP, Petri nets and the π-calculus, such flexibility is already made available within the context of determinate computation. This allows the development of a rich and tractable theory of concurrent processes within the context of which additional computational notion such as indeterminacy, reactivity, instantaneous interrupts and continuous (dense-time) autonomous evolution have been developed.

Path-based rules in object-oriented programming

Abstract: Object-oriented programming has recently emerged as one of the most important programming paradigms. While object-oriented programming clearly owes an intellectual debt to AI, it appears to be displacing some AI techniques, such as rule-based programming, from the marketplace. This need not be so as path-based rules--forward-chaining production rules that are restricted to follow pointers between objects--fit into the object-oriented paradigm in a clean and elegant way. The combination of path-based rules and object-oriented programming should be useful in AI applications, and in the more general problem of transferring AI techniques to the larger computer science community.

Programming in Modula-3

Abstract: The following Modula-3 program uses exceptions. What does it print on its standard output? Explain your answer.

A Logic-Based Concurrent Object-Oriented Programming Language

Abstract: Parallel computers and distributed systems are becoming increasingly important. Their impressive computation to cost ratios offer a considerable higher performance than that possible with sequential machines. Yet there are few commercial applications written for them. The reason is that programming in these environments is substantially more difficult than programming for sequential machines. In this thesis, we present Tempo and Tempo++, two programming languages which aim to reduce the inherent complexity of writing concurrent programs. Tempo is a declarative concurrent programming language based on classical first order logic. It improves on traditional concurrent logic programming languages (e.g. Parlog) by explicitly specifying aspects of the behaviour of concurrent programs. In Tempo all safety properties of programs are declaratively stated which provides great advantages in writing concurrent programs and manipulating them while preserving correctness. Concurrent programs in Tempo are developed in such a way that they are not specific to any particular programming paradigm. The language can be used as a common framework for expressing and manipulating algorithms for a variety of paradigms. Tempo++ is a concurrent programming language which extends Tempo by supporting object-oriented programming, and thus, combines most of the features designed in Tempo with the advantages of the object-oriented approach. That is, in Tempo++, concurrency issues are declaratively abstracted by the explicit specification of the safety properties of programs. As in Tempo, this provides great advantages in writing and manipulating programs. Tempo++ applications can be specified as collections of objects, which incorporates a guiding principle for writing programs and introduces the principles of encapsulation and (multiple) inheritance in a logic programming framework. In the language, concurrency issues are separated from the code, minimizing dependency between application functionality and concurrency control. It is, in general, possible to test different synchronisation schemes without modifying the code of the operations, and conversely, a synchronisation scheme may be reused by several applications. Thus, program reuse and program flexibility are increased.

A Process Algebra for Synchronous Concurrent Constraint Programming

Abstract: Concurrent constraint programming is classically based on asynchronous communication via a shared store. This paper presents new version of the ask and tell primitives which features synchronicity. Our approach is based on the idea of telling new information just in the case that a concurrently running process is asking for it.

Integrating Efficient Records into Concurrent Constraint Programming

Abstract: We show how to implement efficient records in constraint logic programming (CLP) and its generalization concurrent constraint programming (CCP). Records can be naturally integrated into CCP as a new constraint domain. The implementation provides the added expressive power of concurrency and fine-grained constraints over records, yet does not pay for this expressivity when it is not used. In addition to traditional record operations, our implementation allows to compute with partiallyknown records. This fine granularity is useful for natural-language and knowledge-representation applications. The paper describes the implementation of records in the DFKI Oz system. Oz is a higher-order CCP language with encapsulated search. We show that the efficiency of records in CCP is competitive with modern Prolog implementation technology and that our implementation provides improved performance for natural-language applications.

A metrics-driven approach for utilizing concurrency in object-oriented real-time systems

Abstract: This paper presents a metrics-driven process and software toolset for the engineering of concurrent, object-oriented, real-time systems. In the engineering of real-time systems, the objective need not be to exploit all potential concurrency, but to exploit only as much concurrency as is needed to enable satisfaction of timing constraints. Thus, the systems engineering process presented in the paper utilizes inter-object concurrency selectively, as a means to meet timelines. To support the selective use of concurrency, this paper describes techniques for computing inter-object concurrency metrics. It is also shown how the concurrency metrics are used to guide the mapping of objects onto processors.

Object-orientation and the principles of learning theory: a new look at problems and benefits

Abstract: INTRODUCTION Object-orientation as a software development paradigm has existed for some time; its beginnings can be traced to as long ago as the introduction of SIMULA in 1967 (Decker and Hirshfield, 1994; Luker, 1994). The development methods advocated by this paradigm have only more recently been included as serious topics in computer science education, however (Mazaitis, 1993), Currently, as industry increasingly calls for object-oriented methods to be included in undergraduate computer science education, and as object-orientation experiences growing recognition as an acceptable (even preferable) teaching paradigm, many college computer science departments have begun struggling with the task of implementing this methodology into their curricula (Mazaitis, 1993). The difficulty of the task is somewhat troubling since object-oriented techniques are forecasted to become the dominant software development methodology in the near future (Mazaitis, 1993; Lewis, 1993). According to some (Luker, 1994; Lewis, 1993), what is occurring in computer science, and what is reflected in the teaching practices at the college level is a paradigm shift, a revolutionary change away from the currently accepted structured analysis, design, and programming methodologies toward their counterparts in the object-oriented paradigm.

Towards Priority Ceilings in Object-Based Semantic Real-Time Concurrency Control.

Abstract: This paper shows how priority ceiling techniques can be added to object-based real-time semantic concurrency control. The resulting protocol provides more potential concurrency for real-time object-oriented databases than previous priority ceiling techniques, while alleviating priority inversion and deadlock problems of previous object-based semantic concurrency control techniques. It is also a natural extension of priority ceiling techniques to objects in general.

Optimizing COOP languages: study of a protein dynamics program

Abstract: Fine-grained concurrent object-oriented programming (COOP) models can simplify the programming of irregular parallel applications but are often perceived as inefficient. In this paper, we study implementation techniques to obtain efficient parallel execution of fine-grained COOP languages using a medium-sized protein dynamics program. We found that even with high data locality and good sequential code efficiency, an implementation using only thread-oriented optimizations and software multithreading fails to achieve parallel efficiency. The two major sources of overhead are the lack of processor-level data reuse and fine-grained threads for remote object accesses. Two processor-oriented optimizations, processor-level caching and communication grouping, overcome these inefficiencies and achieve performance comparable to a highly-tuned SPMD program.

Using inheritance to implement concurrency

Abstract: 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.

Generating direct manipulation program editors within the MultiView programming environment

Abstract: The MultiView programming environment, which uses a specialisation of the MultiView architecture for multiple view systems, stores program components as abstract syntaz trees and unparses these trees into each of the views of interest. One possible limitation of this approach, however, is that the views may be tied too rigidly to the canonical representation employed and suffer from some of the undesirable characteristics of some past language-specific editors.! This paper describes .some on-going work to investigate novel editing mechanisms which are more flexible and which may thus be more attractive to users than some past editing mechanisms. This work also aims to allow the generation of these views from a description of how the program components should be displayed and manipulated. In this paper, we describe how these ideas have been applied to the specijication of direct manipulation editing of program components in MultiView views.

Applying pi: towards a basis for concurrent imperative programming

Abstract: We study an extension of asynchronous calculus where names can be returned from pro cesses We show that with this simple extension an extensive range of functional state based and control based programming constructs can be expressed by macro expansions similar to Church encodings in lambda calculus