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

The essence of the Visitor pattern

Abstract: For object-oriented programming, the Visitor pattern enables the definition of a new operation on an object structure without changing the classes of the objects. The price has been that the set of classes must be fixed in advance, and they must each have a so-called accept method. In this paper we demonstrate how to program visitors without relying on accept methods and without knowing all classes of the objects in advance. The idea, derived from related work on shape polymorphism in functional programming, is to separate (1) accessing subobjects, and (2) acting on them. In the object-oriented setting, reflection techniques support access to sub-objects, as demonstrated in our Java class, Walkabout. It supports all visitors as subclasses, and they can be programmed without any further use of reflection. Thus a program using the Visitor pattern can now be understood as a specialized version of a program using the Walkabout class.

Detecting concurrency errors in multi-threaded programs

Abstract: A computer implemented method detects concurrency errors in programs. Machine executable images of multiple program threads are instrumented to locate and replace instructions which affect concurrency states of the threads. Concurrency state information is recorded in a memory while the multiple threads are executing. The recorded concurrency state information is analyzed, and inconsistent dynamic concurrency state transitions are reported as concurrency errors.

Interactive mobile agents in X-KLAIM

Abstract: Mobile agents are processes which can migrate and execute on new hosts. Mobility is a key concept for network programming; it has stimulated much research about new programming languages and paradigms. X-KLAIM is an experimental programming language, inspired by the Linda paradigm, where mobile agents and their interaction strategies can be naturally programmed. A prototype implementation of X-KLAIM is presented, together with a few examples introducing the new programming style.

Agent-oriented programming of manufacturing control tasks

Abstract: The success of agent-oriented concepts in various application domains, in particular in manufacturing control, creates the need for an agent-oriented analysis, design, and programming methodology. This paper presents a programming method that covers one step of the necessary methodology. Given a specification of the task to be performed, the method allows to program the corresponding agent in three steps: (i) programming of the individual tasks; (ii) synchronization of tasks to avoid concurrency problems; and (iii) specification of script execution on a single processor machine. The programming method was specifically designed for implementing manufacturing control agents and complies with the industrial requirements stated in this paper.

Web programming in guide

Abstract: Client-server programming is emerging as an important programming paradigm. Especially important, because of the pervasiveness of the HTTP protocol, is the stateless client-server paradigm, used in the so-called ‘Common Gateway Interface’, or CGI. CGI Programmers must deal with a number of design considerations that are not normally important in conventional programs. The most important are persistence and control of concurrent access. We describe these and other CGI programming considerations, and present a new ‘little’ programming language that was designed specifically as a server-side programming language. © 1998 John Wiley & Sons, Ltd.

Constructing compact models of concurrent Java programs

Abstract: Finite-state verification technology (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. Nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finite-state models directly from program source. In this paper, we explore the extraction of compact concurrency models from Java code. In particular, we show how static pointer analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finite-state models of concurrent Java programs.

Interaction of finite state machines and concurrency models

Abstract: Hierarchical concurrent finite state machines (HCFSMs) dramatically increase the usability of finite state machines (FSMs). However, most formalisms that support HCFSMs, such as statecharts (and its variants), tightly integrate the concurrency semantics with the FSM semantics. We, in contrast, allow FSMs to be hierarchically combined with multiple concurrency models, enabling selection of the most appropriate concurrency semantics for the problem at hand. A key issue for the success of this scheme is to define how FSMs interact with various concurrency models without ambiguities. We focus on the interaction of FSMs and three concurrency models: synchronous data-flow, discrete-event and synchronous/reactive models.

A scalable architecture for multi-threaded JAVA applications

Abstract: The paper presents a scalable architecture for multi-threaded Java applications. Threads enable modeling of concurrent behavior in a more or less natural way. Thus threads give a migration path to multi-processor machines. The proposed architecture consists of multiple application-specific processing elements, each able to execute a single thread at one time. The architecture is evaluated by implementing a portable and scalable Java machine onto an FPGA board for demonstration.

Synchronous C++: a language for interactive applications

Abstract: Synchronous C++ defines active objects that contain their own execution threads and can communicate with each other by means of synchronizing method calls. The author shows how to model programs in sC++ and compares sC++ with event driven programming. He focuses on examples in which the dynamic and functional models dominate and the object model is secondary. In doing so, he proposes a mapping between the elements of all three models and sC++ statements. Several other concepts have been proposed to extend OO languages to concurrency: delayed evaluations (a concept that proposes to launch each method on a separate thread, as in Actors), processes orthogonal to the objects (Ada), asynchronous channels and exceptions (Eiffel), and others. However, the researchers who proposed these solutions emphasized the improvements of speed they expected from achieving concurrency, rather than the characteristics that make concurrency suitable for the analysis and the implementation of specifications such as the ones provided by models.

Actors And Agents

Abstract: The terms "actor" and "agent" are used widely in the literature on concurrent and distributed programming both because the underlying concepts to which they refer are fundamental, powerful, and interesting and also because these terms admit of varying interpretations in different technical settings. Historically, the terms "actor" and "agent" have a long association. In the definition of an actor, Hewitt wrote that an actor "is a computational agent which has a mail address and a behaviour." [Hewitt 1977]. Some initial study about the relations between actors and agents may be found in [Gasser and Briot 1992]. The ubiquity and malleability of these terms - the term "agent" in particular - are simultaneously a help and a hindrance to those who work in these areas and for us in organizing a series of papers on current research involving actors and agents. It is clearly helpful to avoid introducing new terminology for distinct, but closely related, concepts. However, confusion is fostered when the term has so many meanings that it is difficult to see the common thread which relates them. The intent of the special series of papers on current work with actors and agents is not to resolve the varying meanings of the terms actor and agent, but to illustrate the spectrum of possibilities, to identify some essential similarities among these concepts, and to indicate the relevance of actor and agent research to concurrency.

What after Java? From objects to actors

Abstract: In this paper, we discuss some drawbacks of the Java programming language, and propose some potential improvements for concurrent object-oriented software development. In particular, we argue that Java's passive object model does not provide an effective means for building distributed applications, critical for the future of Web-based next-generation information systems. Specifically, we suggest improvements to Java's existing mechanisms for maintaining consistency across multiple threads (e.g. synchronized), sending asynchronous messages (e.g. start/run methods) and controlling resources (e.g. thread scheduling). We drive the discussion with examples and suggestions from our own work on the Actor model of computation.

Abstractions for portable, scalable parallel programming

Abstract: In parallel programming, the need to manage communication, load imbalance, and irregularities in the computation puts substantial demands on the programmer. Key properties of the architecture, such as the number of processors and the cost of communication, must be exploited to achieve good performance, but coding these properties directly into a program compromises the portability and flexibility of the code because significant changes are then needed to port or enhance the program. We describe a parallel programming model that supports the concise, independent description of key aspects of a parallel program-including data distribution, communication, and boundary conditions-without reference to machine idiosyncrasies. The independence of such components improves portability by allowing the components of a program to be tuned independently, and encourages reuse by supporting the composition of existing components. The isolation of architecture-sensitive aspects of a computation simplifies the task of porting programs to new platforms. Moreover, the model is effective in exploiting both data parallelism and functional parallelism. This paper provides programming examples, compares this work to related languages, and presents performance results.

Object-Oriented Programming and Java

Abstract: From the Publisher: Object-Oriented Programming and Java teaches two important topics in contemporary software development: object-oriented programming and the Java programming language. The method of teaching object-oriented programming adopted in this book takes a different approach from most available literature. The book begins with the description of real-world object interaction scenarios and explains how they can be translated, represented and executed using object-oriented programming paradigm. This book is suitable for an undergraduate or postgraduate course on object-oriented technology, and in particular, using Java as a programming language for creating object-oriented programs.

Modeling reactive systems in Java

Abstract: We present an application of the Java/sup TM/ programming language to specify and implement reactive real-time systems. We have developed and tested a collection of classes and methods to describe concurrent modules and their asynchronous communication by means of signals. The control structures are closely patterned after those of the synchronous language Esterel, succinctly describing concurrency, sequencing and preemption. We show the user-friendliness and efficiency of the proposed technique by using an example from the automotive domain.

Towards a visual programming environment for software development

Abstract: Visual programming concerns the use of graphical tools and visual metaphors for software. While various visual programming tools have been proposed, their success is largely limited to specialised programming domains. There has been less success in more general programming applications. In this paper we review a subset of the family of visual programming environments and then argue that the potential of visual programming may be better realised within the functional style of programming. Functional programming paradigms offer a range of interesting advantages when extended into graphical/visual environments. The much simpler syntactical rules reduce the range of visual metaphors required to define and facilitate a general programming language and thus may provide some help towards the provision of more robust programming environments.

Agents and concurrent objects

Abstract: The paper considers the main contributions of the notion of an agent and how it differs from object oriented concurrent programming.

Concrete Abstractions: An Introduction to Computer Science Using Scheme

Abstract: From the Publisher: CONCRETE ABSTRACTIONS offers students a hands-on, abstraction-based experience of thinking like a computer scientist. This text covers the basics of programming and data structures, and gives first-time computer science students the opportunity to not only write programs, but to prove theorems and analyze algorithms as well. Students learn a variety of programming styles, including functional programming, assembly-language programming, and object-oriented programming (OOP). While most of the book uses the Scheme programming language, Java is introduced at the end as a second example of an OOP system and to demonstrate concepts of concurrent programming.

Design and implementation of Triveni: a process-algebraic API for threads + events

Abstract: We describe Triveni, a framework and API for integrating threads and events. The design of Triveni is based on an algebra, including preemption combinators, of processes. Triveni is compatible with existing threads standards, such as Pthreads and Java threads, and with the event models structured on the Observer pattern. We describe the software architecture and algorithms underlying a concrete implementation of Triveni in Java. This environment includes specification based testing of safety properties. The results described in the paper have been used to integrate process-algebraic methods into (concurrent) object orientated programming (C. Colby et al., 1998).

Classifying Inheritance Mechanisms in Concurrent Object Oriented Programming

Abstract: Inheritance is one of the key concepts in object-oriented programming. However, the usefulness of inheritance in concurrent object-oriented programming is greatly reduced by the problem of inheritance anomaly. Inheritance anomaly is manifested by undesirable re-definitions of inherited code. The problem is aggravated by the lack of a formal analysis, with a multitude of differing proposals and conflicting opinions causing the current state of research, and further directions, to be unclear. In this paper we present a formal analysis of inheritance anomaly in concurrent object-oriented programming. Starting from a formal definition of the problem we develop a taxonomy of the anomaly, and use it to classify the various proposals. As a result, the major ideas, trends and limitations of the various proposals are clearly exposed. Formal analysis of the anomaly and a thorough exposition of its causes and implications are the pre-requisites for a successful integration of inheritance and concurrency.

Structured programming in Java

Abstract: We argue that for computing majors, it is better to use a 'why' approach to teaching programming than a 'how' approach; this involves (among other things) teaching structured programming before progressing to higher-level styles such as object-oriented programming. We also argue that, once it has been decided to teach structured programming, Java is a reasonable language to choose for doing so.

Classifying inheritance mechanisms in concurrent object-oriented programming

Abstract: Inheritance is one of the key concepts in object-oriented programming. However, the usefulness of inheritance in concurrent object-oriented programming is greatly reduced by the problem of inheritance anomaly. Inheritance anomaly is manifested by undesirable re-definitions of inherited code. The problem is aggravated by the lack of a formal analysis, with a multitude of differing proposals and conflicting opinions causing the current state of research, and further directions, to be unclear. In this paper we present a formal analysis of inheritance anomaly in concurrent object-oriented programming. Starting from a formal definition of the problem we develop a taxonomy of the anomaly, and use it to classify the various proposals. As a result, the major ideas, trends and limitations of the various proposals are clearly exposed. Formal analysis of the anomaly and a thorough exposition of its causes and implications are the pre-requisites for a successful integration of inheritance and concurrency.

Imperative streams—a monadic combinator library for synchronous programming

Abstract: The paper presents a generalization of Haskell's IO monad suitable for synchronous concurrent programming. The new monad integrates the deterministic concurrency paradigm of synchronous programming with the powerful abstraction features of functional languages and with full support for imperative programming. For event-driven applications, it offers an alternative to the use of existing, thread-based concurrency extensions of functional languages. The concepts presented have been applied in practice in a framework for programming interactive graphics.

Testing concurrency and communication in distributed objects

Abstract: Concurrency and communication are two of the key features of distributed systems. These features can make systematic testing of distributed systems a complex task. A major problem is the explosion of the test space because of the potential for arbitrary interference of concurrent threads. This paper describes an approach for systematic testing of such systems in an object-oriented context. We use statecharts for system specification, and model the system behaviour as event-sequences. A test case, therefore, is primarily an event-sequence with concurrent threads represented as interleaving events. Communication-states with associated events represent communication between objects. The test-space explosion is controlled by an extension to Chow's (1978) algorithm for generating test sequences for finite state machines. The number of test sequences we require is O(n/sup 2/), where n is the sum of all events in all concurrent statecharts.

Modeling Java Threads in UML

Abstract: Modern programming languages such as Java facilitate the use of concurrent threads of control within computer applications. Considering concurrency is an important prerequisite for the adequate realization of object-oriented ideas, since real world objects usually operate in parallel. This brings up the requirement to be able to express concurrency issues already in design models, which precede implementation activities. The paper examines the possibilities of modeling Java threads using the Unified Modeling Language (UML). UML is the official industry standard for object-oriented modeling as defined by the Object Management Group (OMG).

An efficient and flexible C++ library for concurrent programming

Abstract: A major problem for the integration of concurrency in object-oriented languages is the so-called inheritance anomaly, i.e. the conflicts between inheritance and concurrency that often cause the need to redefine inherited methods in order to maintain the integrity of objects. Several solutions have been proposed for resolving these conflicts. However, some of them are incomplete, and do not solve all types of inheritance anomaly; others make the definition of classes complex and/or their implementation inefficient. This paper describes a C++ library for concurrent programming that provides a comprehensive framework particularly suitable for coarse-grained distributed applications. This library copes with the inheritance anomaly problem, presenting a solution that minimizes the redefinition of inherited methods without increasing the complexity to write them. This solution is based on the use of a special set of methods, called interface methods, composed of a body and two sets of synchronization constraints. These two sets of synchronization constraints are respectively used to enable the execution of their method body and to disable the methods that cannot be executed after their method. © 1998 John Wiley & Sons, Ltd.

Object and concurrency in Triveni: a telecommunication case study in java

Abstract: We describe the interaction of objects and concurrency in the design of Triveni, a framework for concurrent programming with threads and events. Triveni has been realized as JavaTriveni, a collection of tools for the Java programming language. We describe our experiences in JavaTriveni with an example from telecommunication.

Re-engineering a concurrency simulator

Abstract: SimAda is a concurrency simulator, reengineered from the simulator given in M Ben-Ari, Principles of Concurrent Programming The language was written in Ada 95 to enhance portability and to utilise the structuring constructs of a modern language The concurrency constructs simulated include protected types which are new for Ada 95, as well as the Ada rendezvous Several task scheduling models can be chosen for experimentation SimAda is intended for teaching concurrency, both by running programs and by studying the implementation techniques

Where are the Laws of Object-Oriented Programming?

Abstract: In this position paper we overview ongoing research work aimed at nd-ing and formalizing laws of object-oriented programming. Rather than formal development, our main interest is to guide, justify and document informal object-oriented programming practices. In particular, we focus on laws that support software evolution practices such as introducing common analysis and design patterns. Moreover, contrasting with previous work on programming laws, we investigate both universal and method-speciic laws.