Currently, systematic techniques for assessing macro mechanisms for transferring software engineering technologies are non-existent. This leads to inefficient allocation of research resources and increased risk to software technology intensive programs. Consequently, software technology transition today is an ill-defined and non-repeatable, inefficient process for bringing advanced software engineering technologies to market. This paper develops two dynamical models of a software technology transition from both macroscopic and microscopic views. The models are developed utilizing information theory, communication theory, chaos control theory, and learning curve principles. The combination of those scientifically sound mechanisms provides a basis for assessing, and/or prescribing a portfolio of technologies and the implementing macro infrastructure. This provides the theoretical framework for a practical method for a program manager to establish a high capacity transition channel, which accelerates technology maturation and insertion. Experiments based on very large number of data have been performed. Data samples assess the following technologies: software engineering, software technology transfer, Ada, Java, abstract data types, rate monotonic analysis, cost models, software standards, and software work breakdown structures.

This work presents a novel approach for development of complex real-time systems, called the documentation-driven development (DDD) approach. This approach can enhance integration of computer aided software development activities, which encompass the entire life cycle. DDD will provide a mechanism to monitor and quickly respond to changes in requirements and provide a friendly communication and collaboration environment to enable different stakeholders to be easily involved in development processes and, therefore, significantly improve the agility of software development for complex real-time systems. DDD will also support automated software generation based on a computational model and some relevant techniques. DDD includes two main parts: a documentation management system (DMS) and a process measurement system (PMS). DMS will create, organize, monitor, analyze, and transform all documentation associated with the software development process. PMS will monitor the frequent changes in requirements and assess the effort and success possibility of development. A case study was conducted by a tool set that realized part of the proposed approach.

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.

The major hurdle in developing distributed systems is implementing the interoperability between systems. Currently, most of the interoperability techniques require that the data or services be tightly coupled to a particular server. Furthermore, as most programmers are trained in designing stand-alone application, developing a distributed system proves to be time-consuming and difficult. The paper address the issues by creating an interface wrapper model that allows developers the feature of treating distributed objects as local objects. A tool was developed to generate a Java interface wrapper from a specification language called the Prototyping System Description Language.

This paper summarizes our experiences in using computer-supported methods to develop a software architecture to support the re-engineering of the Janus Combat Simulation System. We have analyzed the Janus FORTRAN source code, interviewed Janus domain experts, developed an object-oriented architecture for the Janus Combat Simulation subsystem, and validated the architecture with an executable prototype. In this paper, we propose methods to facilitate the evolution of the software component of these systems by recovering the behavior of the systems using systematic methods, and illustrate their use in the context of the Janus System.

We describe a distributed requirements engineering environment using computer aided software engineering tools linked together through the Internet. We created this distributed requirements engineering environment using Microsoft's Personal Web Server (PWS), Microsoft's Open Database Connectivity (OPEC) technology, Netscape Communicator, Microsoft's Internet Explorer, Microsoft's Access97 database, and a set of PERL scripts that are executed by users of the environment to perform database operations. We show how we added basic security features to the Internet accessible database.

This paper explores the possibility of automated support for detecting inconsistencies in software systems and requirements. The inconsistencies are introduced when the environment of the software system changes. We refer to the software environment as its context. We review the recent research progress on nonmonotonic logics, pointing out the significance of these results to software maintenance. We explain how a practical implementation of such logics can be obtained via a simple extension to logic programming in the form of an answer procedure that realizes the Extended Logic Semantics [7] for nonmonotonic logic programs that have a unique answer set (which is a large and useful class of logic programs). We augment the existing automated capabilities of the Computer-Aided Prototyping System (CAPS) for rapid prototyping via the extension to logic programming to provide an improved automated capability for detecting certain kinds of inconsistencies created by implicit requirements changes. We illustrate the significance of this capability via an example prototype for a problem originally suggested by Lehman.

Achieving reliability in practice is becoming a dominant issue in software engineering. This paper describes part of a systematic approach to producing reliable software that is based on automated support for software testing. Our approach constructs an automated testing oracle based on software specifications written in the Z specification language. The contextual part of the specification describes the set of legal inputs to the program and the semantics part describes the meaning of the given input data. The potential roles of this approach in improving software reliability are discussed and some future opportunities are indicated.>

In this paper we combine a variation of the CAPS model with an extended version of Prolog based upon the stable model semantics of logic programming [GEL]. We believe this to be the first paper presenting such a combination. In order to combine the CAPS model with the extended Prolog, we first implement a subset of the PSDL language in Prolog. We show the significance of the combination through an example prototype of a problem originally suggested by Lehman (1990). The resulting model provides a general framework for developing prototypes capable of determining when they are in need of adaptive maintenance.>

Rapid prototyping offers an iterative approach to requirements engineering to alleviate problems such as uncertainty, ambiguity, and inconsistency inherent in the process. As the systems development process is characterized by changing requirements and assumptions, involving multiple stakeholders with often differing viewpoints, it will be beneficial to capture in a structured manner the history of the development process. The authors describe how CAPS (computer aided prototyping system) as a prototyping tool, augmented with REMAP (representation and maintenance of process knowledge) framework for reasoning with process knowledge, helps firm up software requirements. This is accomplished by iterative negotiations between various customers and by examination of executable prototypes in the context of evolving requirements.>

This paper presents real-time scheduling methods supporting a prototyping language for embedded systems. Rapid prototyping of embedded systems can be accomplished using a Computer Aided Prototyping System (CAPS) and its associated Prototyping Language (PSDL) to aid the designer in handling hard real-time constraints. The prototyping language PSDL is designed based on the real-time model of CAPS. The language models time critical operations with maximum execution times, maximum response times, minimum or fixed periods, and deadlines. Timing constraints in PSDL are described along with scheduling algorithms relative to a series of hardware models used in the CAPS which includes multiprocessor configurations.>

The authors explore the use of software transformations for software evolution. Meaning-preserving program transformations have been widely used for program development from a fixed initial specification. They consider a wider class of transformations to support development in which the specification evolves, rather than being fixed in advance. A new and general classification of transformations based on their effect on system interfaces, externally observable behavior, and abstraction level of a system description is presented. This classification is used to rearrange chronological derivation sequences containing meaning-changing transformations into lattices containing only meaning-preserving transformations. A process model for software evolution that utilizes prototyping techniques is described. Ways in which this class of transformations can be used to support such a process are considered. A set of examples are presented to illustrate the ideas. Software tool support and directions for future research are discussed.>

The formal semantics of a prototyping language for hard real-time systems, PSDL, is given. PSDL provides a data flow notation augmented by application-orientation timing and control constraints to describe a system as a hierarchy of networks of processing units communicating via data streams. The semantics of PSDL are defined in terms of algebraic high-level Petri nets. This formalism combines algebraic specifications of abstract data types with process and concurrency concepts of Petri nets. Its data abstraction facilities are used to define the meaning of PSDL data types, while high-level Petri nets serve to model the casual and timing behavior of a system. The net model exposes potential concurrency of computation and makes all synchronization needs implied by timing and control constraints explicit and precise. Time is treated as state of clocks, and clocks are modeled as ordinary system components. The net semantics provides the basis for applying analysis techniques and semantic tools available for high-level Petri nets.>

There are at least two different kinds of uncertainty in software development. Both are centered around software specification. The first type has to do with the uncertainty as to whether or not a given description is truly a specification of the software to be developed. The second type of uncertainty has to do with the lifetime of a valid specification. Most programs have parts that are a mixture of the two types. A high-level view of both types of uncertainty in specification is presented to explain the problems inherent in software development and maintenance. The view supports the need for prototyping throughout software development and maintenance.>

The ability of various types of computer-aided prototyping environments to speed up prototyping and help the analysts formulate, understand, and communicate the properties of proposed systems to potential users of those systems, and to integrate smoothly with tools for optimizing and refining the prototype design into a production-quality software product, is examined. Comparisons of software prototyping with system prototyping and of throw-away with evolutionary prototyping are given. The technologies which support prototyping, i.e., prototyping languages, software reuse, designed interfaces, and decision support, are described.>

Prototyping languages form a new category in the computer language family. They are different from the commonly familiar computer languages because they are used to support a higher level of automation at early phases of software development as well as throughout the entire process. They are used to create mechanically processable and executable descriptions or models of proposed software systems. Prototyping languages are also used to firm up requirements via frequent modifications and demonstrations of the models in an iterative process of prototype evolution. The benefits of a prototyping language are fully realized when it is used with its computer-aided prototyping system (CAPS). In this paper, we describe the background, requirements, characteristics, computational features, and general principles for the design of prototyping languages. An example of a prototyping language design is used to illustrate these concepts.

A graph model of software evolution is presented. The author seeks to formalize the objects and activities involved in software evolution in sufficient detail to enable automatic assistance for maintaining the consistency and integrity of an evolving software system. This includes automated support for propagating the consequences of a change to a software system. The evolution of large and complex software systems receives particular attention.>

The use of CAPS (computer-aided prototyping system) for the interactive construction, execution, debugging, modification, and control of software prototypes is presented. The current version of CAPS is discussed, its user interface for monitoring and coordinating the prototype development process is explicated, and the functioning of each of the integrated software tools is shown. CAPS has demonstrated the potential as a significant time- and cost-saving tool in the development of software systems. The primary benefit of incorporating the user interface as part of CAPS is that it helps CAPS develop into a more powerful and advanced form.>

The authors describe the semantics of the real-time language PSDL, which was designed for prototyping real-time systems. They focus on the aspects of the language relating to hard real-time constraints, scheduling, and functional behavior. They present the aspects of PSDL that simplify the description of real-time constraints and clarify the relationships between periodic and data-driven operators and the interactions between timing and control constraints in a language that combines these features.>

Prototype system description language is a high-level real-time language with special features for hard real-time system specification and design. It can be used to firm up requirements through execution of its software prototypes. The language design is based on a real-time model merging data and control flow, and its implementation is beyond conventional compiler technology because of the need to meet real-time constraints. A special scheme used to meet the hard real-time constraints and the guidelines used to implement such a language in the target language Ada are described and illustrated. The required software tools for automated translation and scheduling are also discussed. These tools have been designed, and a prototype version has been partially implemented.>

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. PSDL 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).>