RAPID prototyping, PROTOTYPES, SOFTWARE engineering, COMPUTER software development, USER interfaces (Computer systems), and SYSTEMS design

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]

SOFTWARE engineering, RAPID prototyping, RELATIONAL databases, PROTOTYPES, RELATION algebras, and METHODOLOGY

A method for designing and prototyping program construction systems using relational databases is presented. Relations are the only data structures used inside the systems and for interfaces; programs extensively use relational languages, in particular relational algebra. Two large projects are described. The Ada Relational Translator (ART) is an experimental compiler-interpreter for Ada in which all subsystems, including the parser, semantic analyzer, interpreter, kernel, and debugger, use relations as their only data structure; the relational approach has been pushed to the utmost to achieve fast prototyping in a student environment. Multi-Micro Line (MML) is a tool set for constructing programs for multimicroprocessors' targets, in which relations are used for allocation and configuration control. Both experiences confirm the validity of the approach for managing teamwork in evolving projects, identify areas where this approach is appropriate, and raise critical issues. [ABSTRACT FROM AUTHOR]

RAPID prototyping, PROTOTYPES, and ENGINEERING models

The implementation and maintenance of industrial applications have continuously become more and more difficult. In this context, one problem is the evaluation of complex systems. The IEEE defines Prototyping as a development approach promoting the implementation of a pilot version of the intended product. This approach is a potential solution to the early evaluation of a system. It can also be used to avoid the shift between the description/specification of a system and its implementation. This brief introduction to the special section on Rapid System Prototyping illustrates a current picture of Prototyping. [ABSTRACT FROM AUTHOR]

Modularity, Software architecture, 32-bit operating system, 64-bit operating system, Operating system, Operating systems -- Design and construction, Simulation methods -- Usage, and Mathematical optimization -- Usage

RAPID prototyping, PROTOTYPES, PROCESS control systems, FLEXIBLE manufacturing systems, PETRI nets, and GRAPH theory

This paper presents a methodology for the rapid prototyping of process control systems, which is based on an original extension to classical Petri nets. The proposed nets, called PROT nets, provide a suitable framework to support the following activities: building an operational specification model; evaluation, simulation, and validation of the model; automatic translation into program structures. In particular, PROT nets are shown to be translatable into Ada® program structures concerning concurrent processes and their synchronizations. The paper illustrates this translation in detail using, as a working example, the problem of tool handling in a flexible manufacturing system. [ABSTRACT FROM AUTHOR]

Software engineering, Scientific Research, Program Development Techniques, Database, Programming Language, Rule-Based System, Rapid Prototyping, Object-Oriented Programming, Relational Database, and Software engineering -- Methods

The design and rapid prototyping of data-intensive software applications can be accomplished via the use of Logres and Algres, two advanced database programming languages. Logres, a new-generation programming language, integrates rule-based programming with an object-oriented data model. Algres is a relational system that manages complex database relationships. Algres does not have the necessary programming constructs needed to implement imperative computations. Expressive power and openness to external libraries can be gained by embedding Algres into the C programming language, resulting in the Alice programming interface. THe Logres/Algres software platform allows data-intensive applications to be prototyped rapidly.

HUMAN-computer interaction, COMPUTER operating systems, COMPUTER programming, RAPID prototyping, SOFTWARE engineering, and NONPROCEDURAL languages (Programming languages)

The design of dialog between the user and an interactive program is a demanding and time-consuming task. A promising approach is to provide a system that integrates specification, rapid prototyping, and the actual use of application dialogs. XS-2 is a system that incorporates these aspects: the XS-2 command language gram- mar, a nonprocedural description language based on regular expressions, is used to specify commands of any application program. The syntax of the command specification is visible to the user: command names and their activation rules are displayed as a command tree. Since we provide a small set of tools for the development and automatic translation of the command specification into a prototype application module in Modula-2, no programming work is necessary to design and evaluate the commands of an application. Our experience shows that an advanced end user can develop his own prototype application himself without any programmer's assistance. [ABSTRACT FROM AUTHOR]

Software development/engineering, Network software, Open system, Middleware, Benchmark, Embedded system, Software engineering -- Research, Network software -- Research, Computer software industry -- Research, Benchmarks -- Research, and Embedded systems -- Research

A new specification and design methodology (SDM) called MAGIC (methodology applying generation, integration, and continuity) is presented and discussed.

COMPUTER software, COMPUTER systems, SOFTWARE engineering, and ELECTRONIC systems

Features are often the basic unit of development for a very large software system and represent long-term efforts, spanning up to several years from inception to actual use. Developing an experiment to monitor (by means of sampling) such lengthy processes requires a great deal of care in order to minimize costs and to maximize benefits. Just as prototyping is often a necessary auxiliary step in a large-scale, long-term development effort, so, too, is prototyping a necessary step in the development of a large-scale, long-term process monitoring experiment. Therefore, we have prototyped our experiment using a representative process and reconstructed data from a large and rich feature development. This approach has yielded three interesting sets of results. First, we reconstructed a 30-month time diary for the lead engineer of a feature composed of both hardware and software. These data represent the daily state (where the lead engineer spent the majority of his time) for a complete cycle of the development process. Second, we found that we needed to modify our experimental design. Our initial set of states did not represent the data as well as we had hoped. This is exemplified by the fact that the "Other" category is too large. Finally, the data provide evidence for both a waterfall view and an interactive, cyclic view of software development. We conclude that the prototyping effort is a necessary part of developing and installing any large-scale process monitoring experiment. [ABSTRACT FROM AUTHOR]

Software Design, Prototype, Specifications, Methods, Software engineering, and Software engineering -- Methods

Use of software transformations for software evolution is examined. The effects of software transformations on program synthesis and program optimization have been studied extensively, but it remains difficult to specify the desired behavior of a software system before the implementation is developed. The use of software transformations for developing requirements based on software prototyping is explored. Emphasis is placed on transformations that change a system's behavior. A new, general classification of transformations is presented. The transformations are based on their effects on system interfaces, externally observable behavior and the abstraction level of a system description. A process model for software evolution is described that utilizes prototyping techniques and utilizes the new class of transformations to support the process.

Prototype, Algebraic Languages, Distributed Systems, Formal Languages, Semantics, Real-Time System, Design, Specifications, Programming Language, and Programming languages -- Design and construction

The PSDL prototyping language for hard real-time systems is described. The semi-graphical language provides a data flow notation as well as application-orientation timing and control constraints for describing a system as a hierarchy of networks of processing units that communicate through data streams. The basic PSDL constructs are defined in terms of algebraic high-level Petri nets, combining algebraic specifications of abstract data types with the concurrency and process concepts of Petri nets. The high-level Petri nets model the system's casual and timing behavior. The data abstraction facilities define the meaning of PSDL data types. The net semantics provide a basis for applying the analysis techniques and tools of high-level Petri nets.

BENCHMARKING (Management), COMPUTER software development, COMPUTER input-output equipment design & construction, and COMPUTER engineering

The complexity of hardware/software codesign of embedded real-time signal processing systems can be reduced by rapid system prototyping (RSP). However, existing RSP frameworks do not provide a sound specification and design methodology (SDM) because they require the designer to choose the implementation target before specification and design exploration and they do not work together coherently across development stages. This paper presents a new SDM, called MAGIC, that allows the designer to capture an executable specification model for use in design exploration to find the optimal multiprocessor technology before committing to that technology. MAGIC uses a technique called "virtual benchmarking," for early validation of promising architectures. The MAGIC SDM also exploits emerging open-standards computation and communication middleware to establish model continuity between RSP frameworks. This methodology has been validated through the specification and design of a moderately complex system representative of the signal processing domain: the RASSP Synthetic Aperture Radar benchmark. In this case study, MAGIC achieves three orders of magnitude speedup over existing virtual prototyping approaches and demonstrates the ability to evaluate competitive technologies prior to implementation. Transfer of this methodology to the system-on-a-chip domain using Cadence's Virtual Component Codesign infrastructure is also discussed with promising results. [ABSTRACT FROM AUTHOR]

PROGRAMMING languages, PROTOTYPES, REAL-time computing, ELECTRONIC data processing, COMPUTER software, and SOFTWARE engineering

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]

PROTOTYPES, SPECIFICATIONS, SOFTWARE engineering, APPLICATION software, COMPUTER software development, and SOFTWARE measurement

In this experiment, seven software teams developed versions of the same small-size (2000-4000 source instruction) application soft- ware product. Four teams used the Specifying approach. Three teams used the Prototyping approach. The main results of the experiment were the following. 1) Prototyping yielded products with roughly equivalent performance, but with about 40 percent less code and 45 percent less effort. 2) The prototyped products rated somewhat lower on functionality and robustness, but higher on ease of use and ease of learning. 3) Specifying produced more coherent designs and software that was easier to integrate. The paper presents the experimental data supporting these and a number of additional conclusions. [ABSTRACT FROM AUTHOR]

COMPUTER software, SYSTEMS software, COMPUTER science, COMPUTER software development, TECHNOLOGY, and GRAMMAR

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]

DISTRIBUTED computing, COMPUTER algorithms, COMPUTER software, SOFTWARE engineering, ENGINEERING, and COMPUTER systems

We report our experience in developing a simulator, called Véda. Véda is a software tool to support designers in protocol modeling and validation. It is basically oriented towards the rapid prototyping of distributed algorithms, and has been available for more than two years. Algorithms are described using an ISO formal description technique, called Estelle. We first give an external view of Véda, and particularly how one can describe service properties and tracing, using a specific feature of Véda, called observation. Then, the development of Véda and its internal structure is presented, emphasizing the use of Prolog as a software engineering tool. Typical uses of Véda that have been made in the relatively large community of its users are sketched. We conclude with a critical analysis of the main features of Véda and how they may have contributed to its success. [ABSTRACT FROM AUTHOR]

COMPUTER programming, COMPUTER software development, SYSTEMS design, SOFTWARE engineering, FUNCTIONAL programming (Computer science), and SOFTWARE architecture

Functional programming has enormous potential for reducing the high cost of software development. Because of the simple mathematical basis of functional programming it is easier to design correct programs in a purely functional style than in a traditional imperative style. We argue here that functional programs combine the clarity required for the formal specification of software designs with the ability to validate the design by execution. As such they are ideal for rapidly prototyping a design as it is developed. We give an example which is larger than those traditionally used to explain functional programming. We use this example to illustrate a method of software design which efficiently and reliably turns an informal description of requirements into an executable formal specification. [ABSTRACT FROM AUTHOR]

COMPUTER programming, PROGRAMMING languages, COMPUTER multitasking, PROTOTYPES, PRODUCTION scheduling, and AUTOMATIC programming (Computer science)

A specification language is introduced, able to define con- current programs behavior. The language is particularly devoted to describe distributed applications, mainly with respect to scheduling problems. For this purpose, the language allows visibility of the "past history" of a computation and such history may be explicitly used to drive the choices on the future behavior of the computation itself and to define the values exchanged at each communication. A behavior is a partial order on events (communications) accomplished by processes, while the values of the communications are specified by a functional language. The most noticeable characteristic of specifications written in this language is the capability to be easy translated into executable concurrent programs (written into a CSP-like concurrent language), so obtaining an early prototype for these programs. An algorithm is described to accomplish the translation. An environment is provided to support static semantics checks on specifications, while dynamic testing and debugging are accomplished using interactive tools of the concurrent language environment. [ABSTRACT FROM AUTHOR]

DISTRIBUTED computing, COMPUTER software, ENGINEERING, SOFTWARE engineering, and ELECTRONIC systems

In this paper, we describe a specification model that is based on the finite state machine but is distributed. The model allows the user to decompose a large system into separate views. Each view is a complete system in itself, and reveals how the whole system would behave as seen from a certain angle. Put together, the combined views present a complete picture of the whole system. The complexity of a large centralized system is thus distributed and subdued. We then offer a simple execution scheme for our model. Using a high-level state-transition language called SXL, constructs in the model are expressed as pre- and postconditions of transitions. The execution scheme allows all the views in the model to proceed in a parallel but harmonius way, producing a working prototype for the modeled system. [ABSTRACT FROM AUTHOR]

SOFTWARE engineering, RAPID prototyping, PROTOTYPES, COMPUTER software, PROGRAMMING languages, and SOFTWARE architecture

Several current research efforts in software engineering are investigating executable formal specification languages. The availability of executable specification languages allows testing to be carried out soon after or concurrently with the requirements specification phase. In addition, it becomes possible to use these languages for rapid prototyping, making it possible to gather information on properties of the specified target system including its behavior in response to external events. In this paper, the inspection of software behavior is viewed as the querying of executable specifications. A language RSQ is defined for the purpose of constructing queries against executable specifications expressed in RSF, a language for the description of systems with time constraints. A query is able to single out a subclass of possible behaviors based on properties supplied by the query. The integration of RSQ with RSF enhances the analytical abilities of the software designer and developer. [ABSTRACT FROM AUTHOR]