the complexity of functions to be performed,
the fact that execution tends to be distributed on several processors, and
the constant evolution of execution environments (hardware + software).
In the early parts of the development, such as requirements and design specifications, the formulation of requirements using natural languages, as well as potential misunderstanding between users and designers of the future system, tend to produce errors that will have a lasting influence on reliability, safety, and cost of the system [ 8].
In later parts of the development, such as implementation and deployment, programming constraints may introduce alterations in the system (even if it is well-described). Moreover, specifications may often be interpreted in various ways, leading to so-called "integration problems" [ 10].
Maintenance is usually performed on programs. Thus, variations in time introduce significant differences between the original specification and the maintained application. If specifications and environmental restrictions are not maintained and validated across changes, implicit assumptions can easily be violated, leading to costly failures such as that of Ariane 5 [ 6].
collect criticisms and feedback for updated requirements,
detect deviations from users' expectations early,
trace the evolution of the requirements,
improve the communication and integration of the users and the development personnel, and
provide early warning of mismatches between proposed software architectures and the conceptual structure of requirements.
3.2.1 The Throw-Away Approach The main advantage of the throw-away approach is that it enables the use of special-purpose languages and tools, even if they introduce limitations that would not be acceptable in an operational environment or even if they are not capable of addressing the entire problem. The throw-away approach is most appropriate in the project acquisition phase where the prototype is used to demonstrate the feasibility of a new concept and to convince a potential sponsor to fund a proposed development project. In such a context, available resources are limited and the ability to communicate the advantages of a new approach via a very low cost demonstration can be critical for creating a new project.
The most apparent disadvantage of a throw-away prototype is spending implementation effort on code that will not contribute directly to the final product. There is also the temptation to skip or abbreviate documentation for throw-away code. This temptation is harmful because the lessons learned from the prototyping effort may be lost if they are not recorded and because the lack of documentation and degradation of the initial design simplicity may block the evolution of the prototype before it reaches a form that captures the customer's needs with respect to the scope of the prototyping effort. The throw-away approach can be a stopgap for an inadequate level of technology and is most appropriate for rough system mock-ups used at the very earliest stages of a project.
3.2.2 The Evolutionary Approach The evolutionary approach produces a series of prototypes in which the final version becomes the software product. This approach depends on special tools and techniques because it is usually not possible to put a prototype into production use without significant changes to its implementation to optimize the code and to complete all of the details. The conceptual models and designs contained in a prototype can usually be used in the final version. Precise specifications for the components of a prototype and clear documentation of its design are therefore critical for effective software prototyping, as are tools for transforming and completing designs and implementations. The technology needed to support this approach is beginning to emerge.
Modeling is necessary to be able to capture the architecture and the behavior of the system to be developed.
Evaluation of the model can be performed through simulation or testing; in some cases, formal techniques are also applicable.
Automated program generation from the model provides an accurate image of the system without the variations that may be introduced during the coding phase.
Reuse of software components in applications still provides some difficulties for a prototyping-based approach (especially when formal methods are used) since only parts of the system are described in the model prototype.
The choice of an appropriate notation for the model prototype is not easy. If UML is now a standard for design of systems, it still cannot be considered in many application domains (such as distributed systems, real-time systems, etc.).
The link between the model prototype and formal verification techniques remains delicate. A solution is to specify the system by means of a formal notation, but it appears to be impracticable: This is impossible for large systems and requires that engineers have a strong education in formal methods, which is not realistic.
The automation of the verifications performed on the model prototype is necessary to enable a larger use of prototyping-based development. Whether the verification is formal or not, techniques are not easy to manipulate and should be automated.
Existence of user friendly tools is a prerequisite for a larger use of prototyping based development.
Point 1: Prototyping-based methodologies are of interest because they allow us to reduce the cost and time-to-market of a system. For companies producing complex systems (such as embedded, distributed, real-time, etc.), there is an additional reason: The cost of highly skilled engineers increases rapidly since there is more demand than people to fill positions. Automated development approaches could reduce the need for highly skilled engineers since one of them could manage several "standard" engineers to operate prototyping tools.
Point 2: For companies building critical systems, a prototype-based approach is even more interesting since it is more likely able to operate formal verification techniques when required. It is now clear that such methods are the only way to provide extremely high levels of reliability in system design and implementation. This is why it is recommended by various certification standards such as DO-178B (for avionic systems).
F. Kordon is with the Computer Science Department, Université Pierre & Marie Curie, 4 place Jussieu, 75252 Paris Cedex 05, France.
Luqi is with the Computer Science Department, Naval Postgraduate School, 1 University Cir., Monterey, CA 93943-5001.
For information on obtaining reprints of this article, please send e-mail to: email@example.com, and reference IEEECS Log Number 116718.
Fabrice Kordon received the PhD degree in computer science in 1992 from the University P. & M. Curie (Paris, France) and is currently a professor of computer science at this university where he chairs a team involved in prototyping techniques for distributed systems (modeling, formal verification using Petri nets, automatic program generation). Since 1994, his team has distributed on Internet CPN-AMI: a Petri net-based CASE environment dedicated to the formal verification of distributed systems which is used for teaching and reseach in many research institutes. He is on the program committees of several conferences dedicated to formal methods and software engineering. He was the general cochair for the IEEE Rapid System Prototyping Workshop in 2000 and 2001 prior to being program cochair in 2002.
Luqi received the PhD degree in computer science from the University of Minnesota in 1986. Since graduation she has worked for the Science Academy of China, the Computer Center at the University of Minnesota, and in industry. She is currently a professor of computer science at the US Naval Postgraduate School, where she chairs the Software Engineering Program and leads a team producing highly automated software tools, including CAPS (Computer-Aided Prototyping System). She has received a Presidential Young Investigator Award from the US National Science Foundation and the 1997 Technical Achievement Award from the IEEE Computer Society for her research on the enabling technologies for computer-aided prototyping of real-time systems. For three years now, she has chaired the IEEE annual Rapid System Prototyping Workshop. In addition to chairing or serving on the program committees of more than 40 conferences, she is or has been an associate editor for IEEE Expert, IEEE Software, the Journal of Systems Integration, and Design and Process World. She is a fellow of the IEEE.