Search

Performance of computer-based systems may depend on many different factors, internal and external. In order to design a system to have the desired performance or to validate that the system has the required performance, the effect of the influencing factors must be known. Common methods give no or little guidance on how to vary the factors during prototyping or validation. Varying the factors in all possible combinations would be too expensive and too time-consuming. This paper introduces a systematic approach to the prototyping and the validation of a system's performance, by treating the prototyping or validation as an experiment, in which the fractional factorial design methodology is commonly used. To show that this is possible, a case study evaluating the influencing factors of the false and real target rate of a radar system is described. Our findings show that prototyping and validation of system performance become structured and effective when using the fractional factorial design. The methodology enables planning, performance, structured analysis, and gives guidance for appropriate test cases. The methodology yields not only main factors, but also interacting factors. The effort is minimized for finding the results, due to the methodology. The case study shows that after 112 test cases, of 1,024 possible, the knowledge gained was enough to draw conclusions on the effects and interactions of 10 factors. This is a reduction with a factor 5-9 compared to alternative methods. [ABSTRACT FROM AUTHOR]

A methodology for the design and development of data parallel applications and components is presented. Data-parallelism is a well-understood form of parallel computation, yet developing simple applications can involve substantial efforts to express the problem in low-level notations. We describe a process of software development for data-parallel applications starting from high-level specifications, generating repeated refinements of designs to match different architectural models and performance constraints, enabling a development activity with cost-benefit analysis. Primary issues are algorithm choice, correctness, and efficiency, followed by data decomposition, load balancing, and message-passing coordination. Development of a data-parallel multitarget tracking application is used as a case study, showing the progression from high to low-level refinements. We conclude by describing tool support for the process. [ABSTRACT FROM AUTHOR]

This paper discusses general requirements for architecture definition languages, and describes the syntax and semantics of the subset of the Rapide language that is designed to satisfy these requirements. Rapide is a concurrent event-based simulation language for defining and simulating the behavior of system architectures. Rapide is intended for modelling the architectures of concurrent and distributed systems, both hardware and software. In order to represent the behavior of distributed systems in as much detail as possible, Rapide is designed to make the greatest possible use of event-based modelling by producing causal event simulations. When a Rapide model is executed it produces a simulation that shows not only the events that make up the model's behavior, and their timestamps, but also which events caused other events, and which events happened independently. The architecture definition features of Rapide are described here: event patterns, interfaces, architectures and event pattern mappings. The use of these features to build causal event models of both static and dynamic architectures is illustrated by a series of simple examples from both software and hardware. Also we give a detailed example of the use of event pattern mappings to define the relationship between two architectures at different levels of abstraction. Finally, we discuss briefly how Rapide is related to other event-based languages. [ABSTRACT FROM AUTHOR]

Rapide is an event-based, concurrent, object-oriented language specifically designed for prototyping system architectures. Two principle design goals are 1) to provide constructs for defining executable prototypes of architectures and 2) to adopt an execution model in which the concurrency, synchronization, dataflow, and timing properties of a prototype are explicitly represented. This paper describes the partially ordered event set (poset) execution model and outlines with examples some of the event-based features for defining communication architectures and relationships between architectures. Various features of Rapide are illustrated by excerpts from a prototype of the X/Open distributed transaction processing reference architecture. [ABSTRACT FROM AUTHOR]

Prototyping, a method and technique frequently used in many engineering disciplines, has been adopted as a technique in software engineering to improve the calculation of new projects involving risks. However, there has so far been a lack of documented experience with the use of prototyping in industrial software production. The present work tries to close this gap. First, we introduce central prototyping concepts and terminology. In the subsequent section we present five industrial software projects in which explicit use was made of prototyping. Based on our analysis of these projects we present the resulting conclusions: prototyping means more than rapidly developing user interfaces; prototyping is a central part of a development strategy; prototyping means end user involvement; finding the right mixture of prototypes improves the development process. [ABSTRACT FROM AUTHOR]

The development of quality software depends upon making appropriate decisions at every stage of the life cycle. Given a design, many techniques have been developed to produce quality code from that design. However, ignored so far have been formal models to help the software manager to make appropriate implementation decisions. A model for evaluating software designs has been proposed and is based upon extending the functional model of program verification with concepts from economic decision theory. This paper briefly describes the method, and describes a prototype implementation of a tool, called Selector, which implements this technique. [ABSTRACT FROM AUTHOR]

Petri nets are a powerful formalism for the specification and analysis of concurrent systems. Thanks to their flexibility, they have been extended and modified in several ways in order to match the requirements of specific application areas. In particular, since Petri nets easily model control flow, some extensions have been proposed to deal with functional aspects while others have taken timing issues into account. Unfortunately, so far little has been done to integrate these aspects, that are crucial in the case of time-critical systems. In this paper, we introduce a high-level Petri net formalism (ER nets) which can be used to specify control, function, and timing issues. In particular, we discuss how time can be modeled via ER nets by providing a suitable axiomatization. Then, we use ER nets to define a time notation (called TB nets), which is shown to generalize most time Petri net-based formalisms which appeared in the literature. Finally, we discuss how ER nets can be used in a specification support environment for time critical system and, In particular, the kind of analysis supported. [ABSTRACT FROM AUTHOR]

PSDL is a language for describing prototypes of real-time software systems. It is most useful for requirements analysis, feasibility studies, and the design of large embedded systems. PSUL has facilities for recording and enforcing timing constraints, and for modeling the control aspects of real-time systems using nonprocedural control constraints, operator abstractions, and data abstractions. The language has been designed for use with an associated prototyping methodology. PSDL prototypes are executable if supported by a software base containing reusable software components in an underlying programming language (e.g., Ada). [ABSTRACT FROM AUTHOR]

Languages are critical to the successful use of computers in solving problems. Languages are useful not only in specifying how to compute solutions, but in conceptually understanding and describing solutions. Recent advances in software technology lie mostly in more sophisticated tools and models of computation as reflected in languages. The usefulness of language is difficult to overstate—a computer's sophistication depends directly on the sophistication of the languages of the computer's editors, compilers, and command interpreters. Perception of this usefulness has led to much research in the classification, characterization, and recognition of languages. In spite of the major successes of language theory, translator construction still remains a black art of computer science. The regular expressions, terminals, nonterminals, and grammars in which the translator writer thinks are nowhere to be found in the translators he writes, except perhaps in comments and as abstract entities associated with particular pieces of code. Here the uses and advantages of a language tailored specifically for the description and construction of translators are considered. [ABSTRACT FROM AUTHOR]

Typical software engineering courses teach principles in lectures and readings, then apply them in the development of a single program (requiring several months). We recently taught a software engineering class that incorporated many smaller exercises (requiring several hours). The class was successful: students were able to experiment with a broad set of ideas, and make interesting mistakes without jeopardizing the grades of their development team. This paper describes some tools and techniques we taught, and suggests how they might be incorporated into typical software engineering classes. [ABSTRACT FROM AUTHOR]

The development of correct specifications is a critical task in the software development process. This paper describes an alternative approach for the development of specifications. The approach relies on a specification language for abstract data types and a synthesis system. The system is capable of translating an abstract data type specification into an executable program. This process defines an alternative methodology that provides the necessary tools for the early testing of the specifications and for the development of prototypes and implementation models. [ABSTRACT FROM AUTHOR]

Automatic programming consists not only of an automatic compiler, but also some means of acquiring the high-level specification to be compiled, some means of determining that it is the intended specification, and some (interactive) means of translating this high-level specification into a lower-level one which can be automatically compiled. We have been working on this extended automatic programming problem for nearly 15 years, and this paper presents our perspective and approach to this problem and justifies it in terms of our successes and failures. Much of our recent work centers on an operational testbed incorporating usable aspects of this technology. This testbed is being used as a prototyping vehicle for our own research and will soon be released to the research community as a framework for development and evolution of Common Lisp systems. [ABSTRACT FROM AUTHOR]

This paper describes an approach to software specification development with interpretation as applied to an information storage and retrieval system. Machine execution of software specifications is possible with both partial and complete specifications. A partial specification is interpreted using abstract execution. The Descartes specification language is utilized to describe a functional aspect of an existing information storage and retrieval system, namely, the MADAM (Multics Approach to Data Access and Management) system at the University of Southwestern Louisiana. Brief descriptions of both the Descartes language and the MADAM system precede the example specification. The paper concludes with a discussion of the expected results that this methodology could have on the pragmatic development and evolution of information systems. [ABSTRACT FROM AUTHOR]

The present crisis in software development forces us to reconsider the fundamental ways in which programming is done. One often quoted solution is to exploit more fully the idea of reusable software. It is the purpose of this paper to examine this concept in all of its forms and to assess the current state of the art. In addition to its usual meaning of reusable code, reusability includes reusable design, various forms of specification systems, so-called application generators. and systems for prototyping. We examine each approach from the perspective of the practicing engineer, and we evaluate the work in terms of how it may ultimately improve the development process for large-scale software systems. [ABSTRACT FROM AUTHOR]

A recent paper compared several axiomatic methods of formal specification, one of which was Z [1]. As a result of a comparison I made between Z and a similar, but executable, specification language called me too [2], Simon Finn pointed out that one of the Z specification given in that paper was not correct. This correspondence describes the erroneous function and draws some conclusions about the process of formal specification. [ABSTRACT FROM AUTHOR]