PROSET — A Language for Prototyping with Sets

We discuss the prototyping language PROSET(Prototyping with Sets) as a language for experimental and evolutionary prototyping, focusing its attention on algorithm design. Some of PROSET’s features include generative communication, flexible exception handling and the integration of persistence. A discussion of some issues pertaining to the compiler and the programming environment conclude the pape

AiGERM: A logic programming front end for GERM

AiGerm (Artificially Intelligent Graphical Entity Relation Modeler) is a relational data base query and programming language front end for MCC (Mission Control Center)/STP's (Space Test Program) Germ (Graphical Entity Relational Modeling) system. It is intended as an add-on component of the Germ system to be used for navigating very large networks of information. It can also function as an expert system shell for prototyping knowledge-based systems. AiGerm provides an interface between the programming language and Germ

Approaches to High-Level Programming and Prototyping of Concurrent Applications

Concurrent programming is conceptually harder to undertake and to understand than sequential programming, because a programmer has to manage the coexistence and coordination of multiple concurrent activities. To alleviate this task several high-level approaches to concurrent programming have been developed. For some high-level programming approaches, prototyping for facilitating early evaluation of new ideas is a central goal. Prototyping is used to explore the essential features of a proposed system through practical experimentation before its actual implementation to make the correct design choices early in the process of software development. Approaches to prototyping concurrent applications with very high-level programming systems intend to alleviate the development of parallel algorithms in quite different ways. Early experimentation with alternate design choices or problem decompositions for concurrent applications is suggested to make concurrent programming easier. This paper presents a survey of approaches to high-level programming and prototyping of concurrent applications to review the state of the art in this area. The surveyed approaches are classified with respect to the prototyping process

Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

Implementing Parallel Algorithms based on Prototype Evaluation and Transformation

Combining parallel programming with prototyping is aimed at alleviating parallel programming by enabling the programmer to make practical experiments with ideas for parallel algorithms at a high level, neglecting low-level considerations of specific parallel architectures in the beginning of program development. Therefore, prototyping parallel algorithms is aimed at bridging the gap between conceptual design of parallel algorithms and practical implementation on specific parallel systems. The essential prototyping activities are programming, evaluation and transformation of prototypes. This paper gives a report on some experience with implementing parallel algorithms based on prototype evaluation and transformation employing the ProSet-Linda approach

Investigating strategies for cooperative planning of independent agents through prototype evaluation

This paper discusses the application of the prototyping approach to investigating the requirements on strategies for cooperative planning and con ict resolution of independent agents by means of an example application: the strategic game \Scotland Yard". The strategies for coordinating the agents, which are parallel algorithms, are developed with a prototyping approach using ProSet-Linda. ProSet-Linda is designed for prototyping parallel algorithms. We concentrate on the techniques employed to elicit the requirements on the algorithms for agent interaction. The example application serves to illustrate the prototyping approach to requirements elicitation by means of a non-trivial instance for investigating algorithms for cooperative planning and con ict resolution

Investigating Strategies for Cooperative Planning of Independent Agents through Prototype Evaluation

This paper discusses the application of the prototyping approach to investigating the requirements on strategies for cooperative planning and conflict resolution of independent agents by means of an example application: the strategic game "Scotland Yard". The strategies for coordinating the agents, which are parallel algorithms, are developed with a prototyping approach using ProSet-Linda. ProSet-Linda is designed for prototyping parallel algorithms. We concentrate on the techniques employed to elicit the requirements on the algorithms for agent interaction. The example application serves to illustrate the prototyping approach to requirements elicitation by means of a non-trivial instance for investigating algorithms for cooperative planning and conflict resolution

Rapid software prototyping

Rapid Prototyping is an approach to software development which emphasizes quick implementation of a working program. This dissertation makes two principal contributions. First, it provides concepts, techniques, and a philosophy of Rapid Software Prototyping and characterizes the benefits and limitations of its use. Second, it makes a contribution to programming environments which support Rapid Prototyping. An experimental language, Castor, is described which was implemented to validate this approach in the prototyping of Ada programs*. The following summarize the main results of this research:..

Investigating Parallel Interpretation-Tree Model Matching Algorithms with ProSet-Linda

This paper discusses the development of algorithms for parallel interpretation-tree model matching for 3-D computer vision applications such as object recognition. The algorithms are developed with a prototyping approach using ProSet-Linda. ProSet is a procedural prototyping language based on the theory of finite sets. The coordination language Linda provides a distributed shared memory model, called tuple space, together with some atomic operations on this shared data space. The combination of both languages, viz. ProSet -Linda, is designed for prototyping parallel algorithms. The classical control algorithm for symbolic data/model matching in computer vision is the Interpretation Tree search algorithm. This algorithm has a high computational complexity when applied to matching problems with large numbers of features. This paper examines parallel variations of this algorithm. Parallel execution can increase the execution performance of model matching, but also make feasible entirely new ways of solving matching problems. In the present paper, we emphasize the development of parallel algorithms with a prototyping approach, not the presentation of performance figures displaying increased performance through parallel execution. The expected improvements attained by the parallel algorithmic variations for interpretation-tree search are analyzed. The implementation of ProSet-Linda is briefly discussed

Using non-functional requirements in component-based software construction

The main concern of this paper is to present the author's approach to support software development in the component programming framework taking functional and non-functional requirements into account. Functional requirements are written as algebraic specifications, while non-functional information is bound to specifications and implementations by means of ad hoc modules: the nonfunctional information is used to select automatically the most appropriate implementations of software components (the selection algorithm is not presented here). The existence of multiple type implementations is supported by a process model based on the prototyping paradigm. Prototyping is achieved by means of a mixed execution mechanism being able to operate in the context of incremental software development process allowing the execution of incomplete (partially implemented) systems. The ideas we present here are not bound to any particular programming language, giving rise to a method of wide applicability.Peer ReviewedPostprint (published version