An Overview Of Prototyping

Published Date: 02 Nov 2017

Introduction

In this lecture we present prototyping in software engineering. We first, present its definition, objectives, advantages and disadvantage. Then, we present sequence of prototyping in the software development life cycle. We also present the process of prototyping and its steps. We then, present types of the prototyping including throwaway prototyping, evolutionary prototyping, incremental, and extreme. We finally present prototyping tools including White-board, fourth generation languages, specification-level description language, CASE tools, use cases, and entity relationships diagrams.

Learning Outcomes

Understanding the importance of prototyping

Be familiar with the various types of prototyping

Be familiar with Entity Relationship Diagrams

1.0 Introduction

Prototyping is the process of building a model of a system. It allows developers to develop a nearly-fully-functioning model of the final product. The IEEE 610.12 standard defines a prototype as a "preliminary form or instance of a system that serves as a model for later stages for the final complete version of the system". In software engineering, prototypes are used to help in the creation of an information system that will be easy to use, user friendly and accessible for end users. Prototyping is not a one off procedure carried out by designers. It is an iterative process that is carried out many times during the development life cycle.

In this lecture we present prototyping, its types, tools and methodology.

2.0 An Overview of Prototyping

While the requirements of the system are being identified, the current business procedures (which are going to be affected by the new system) of an organization are analyzed and evaluated by the system analysts. In addition to this, system analysts gather information from akin systems for comparison purposes. Once that is completed, a first draft of the system requirement is prepared.

Prototyping goes hand in hand with the above process as it helps to translate intangible and at times vague requirements into a visual a more concrete one, by portraying the requirements visually, i.e. as a diagram.

The user feedback gained from the developed model (a model that can be seen, touched and interacted with) is used by the analyst to alter the existing requirements and in most cases, create new ones.

Prototyping has many forms. The simplest form of prototyping is low tech sketches or paper screens. Other forms, which are more advanced, include ‘high-tech operational systems’ that utilize CASE (computer-aided software engineering).

The prototype can be used to assist in the analysis and design phase, rather than a software product.

A prototype has two dimensions: horizontal and vertical. Horizontal prototype is user interface prototyping. It concentrates on the interaction between the user and the interface of the system, disregarding the low level processes that occur during this interaction i.e. database fetching and information retrieval. Horizontal prototypes are useful for specification and setup of user interface requirements and system scope. They are also used as a demonstration version of the system and to develop preliminary estimates of development time, cost and effort.

Vertical Prototype is a more complete model of a single project or project component than a horizontal model. It is used to obtain a detailed requirement for a given project. Vertical Prototype is used to refine database design, obtain information on data volumes and system interface needs, and to clarify complex requirements by dealing with actual system functionality.

There are many advantages of prototyping in software development. Some of these advantages are tangible, and some are more abstract. These advantages include the following:

Reduces development time

Reduces development costs

Users expect what the system will look like

Results in higher user satisfaction

Involves the users

Involves user quantifiable feedback

Facilitates system implementation

Exposes developers to potential future system enhancements.

Improved and increased user involvement: Users are involved and interact with the prototype

Prevents many misunderstandings and miscommunications between developers and users.

Prototyping leads to increased interaction between developers and users, which as a result, leads to a more complete system that meets it initial objectives.

Communication gap between software developer and clients may be identified.

Ambiguous user requirements may be clarified.

A small working system is quickly built to demonstrate the feasibility and usefulness of the system.

Using, or perhaps misusing, prototyping can have some disadvantages. Some of the disadvantages of prototyping include the following:

Can lead to insufficient analysis: The focus on a limited prototype can distract developers from properly analyzing the complete project.

Due to the requirements not being fully established, the prototype which is based on the requirements, once created, may be based on incorrect requirements or incomplete ones.

The limited scalability of a prototype can at times be forgotten. Users as well as designers forget that the prototype is not a fully functioning version of the end product and designers think that it can be easily scaled to reach the desired state of a final product.

Users get the perception that the final version of the product is the same as the prototype they are using/testing.

Developers can become too attached to their prototypes

Sometimes leads to incomplete documentation.

The sequence of prototyping in the software development life cycle is shown in Figure 1.

Requirements gathering

Quick design

Build prototype

Users evaluate prototype

Refine prototype

Implement system

Start

Stop

Figure 1: The sequence of prototyping in the software development life cycle

The process of prototyping involves the following steps:

Initial system requirements are established and issues such as system security are not considered at this stage.

A user-interface prototype is developed which only tests the interaction between the user and the system, ignoring low level processes.

Feedback is provided from the stakeholders, concentrating on the end-users/customers.

Based on the feedback provided, alterations are carried out on the prototype.

If changes are introduced then a repeat of steps #3 and #4 may be needed.

Use of prototyping in information systems design process is carried out in four steps:

First step: quick analysis where the system developers understand the user's basic information needs and requirements

Second step: construct the initial prototype using user's defined needs and requirements.

Third step: users and system developers evaluate of the prototype

Fourth step: system developers modify and improve the prototype system.

In the prototype evaluation period, the user assesses the behavior of the system by comparing the actual behavior with that of the prototype. If the prototype cannot run with satisfaction, the user can immediately identify the problem and make modifications to the requirements by redefining them. This process continues until the user is satisfied with the prototype and by making sure that it can successfully reflect the imagination of the system.

Prototyping is a popular technique used in the design process as it facilitates and increases the interaction between the designer/developer and the end user. Organizations use prototyping very frequently in development projects, and the technique is only introduced when the development cycle is at the appropriate stage i.e. a requirements specification has been established and the prototype is developed based on that. End users who participate in the testing should have prototyping experience or be trained on the use and purpose of prototyping. This also applied to developers, as they should also have a complete background and experience in this area.

Prototyping is the best solution to the requirements analysis problem. Prototypes allow users to visualize an application that has not yet been constructed. Prototypes help users get visualize what the system will look like. As a result, this will make it easier for them to communicate their thoughts and feedback/alterations to the designers. Also, another advantage of prototypes is the fact that it is an iterative process where many prototypes can be created throughout the design stage, allowing the users to have an input before the final product is developed. System prototypes lead to fewer changes later and hence reduce overall costs considerably.

Software prototyping is a technique that involves the creation of unfinished software which provides the testers with an idea of the behavior of the final version. This means to create incomplete versions of the software program being developed. A software prototype is the first version of the software to be developed. It is developed with minimal cost, and the shortest time to reflect the main features of the final software system.

In most cases, a prototype only represents a few parts of the final version and could also be entirely different from it.

A software prototype enables software designers and implementers to gain important feedback from end-users, at the beginning of the development cycle. Both the end-users and the developers can continuously evaluate the prototype, comparing it to the requirements specification, which is what the product is based on. Software prototyping does not only aid in the design process, it is also used for project planning/management purposes as the progress of the initial project plan can be compared to the progress of the product.

A software prototype has the following characteristics:

It is an actual running system

It has no fixed life span. It could be discarded (thrown away prototype) after it is used or it could be a part of the final product (incremental prototype).

It must be fast and cheap.

It is an integrated part of the iterative process, which changes each time after a user feedback/testing.

Prototyping is used in the analysis and documentation of system requirements.

2.1 Types of Prototypes

Software prototyping has many variants. Mainly, the prototypes are developed using the following two techniques:

Throwaway prototyping and

Evolutionary prototyping.

On the following, we describe each of these types as well as other less popular types.

2.1.1 Throwaway Prototyping

Throwaway prototyping is also called close-ended prototyping. Throwaway prototyping is a rapid prototyping. In this technique, the prototype is discarded after its purpose is fulfilled and the final system is built from scratch. The prototype does not become a part of the final delivered system. The prototype is built quickly to enable the user to rapidly interact with a working system. Since the prototype is finally discarded, its speed, implementation aspects, maintainability and fault tolerance are not highly important. The prototype is developed as follows: in requirements analysis phase, a small set of requirements (or preliminary requirements) of the complete requirements are defined in a short period of time to save project total time. Then, a user-interface model is developed to help the end-users visualize what the product will look like and how their requirements are being met/carried out. The prototype is constructed using these requirements to determine the feasibility of project/system. Using this prototype the function of the system is validated. During this phase any missing requirements are defined. After that, the user interface is developed.

The steps in this prototyping approach to develop the system are as follows:

Write preliminary requirements (a small set of the complete requirements)

Design the prototype

Get user feedback, user experiences where users use/test the prototype, and specify new requirements

Repeat the development of the prototype if necessary

Write the final requirements

Develop the system

The advantages of throwaway prototyping are that it decreases the total system/project development time where the duration of prototype building should be as less as possible. The most important reason for using throwaway prototyping is that it can be developed quickly and the prototype/model is developed with high speed. The usability of the developed prototype exists only if results from its use are available in timely fashion. Other advantages of the throwaway prototyping include the following:

Quick feedback is provided to the users in relation to their requirements

The prototype enables Making changes early in the development lifecycle

The prototype is extremely cost effective since there is nothing needs to be undone/redone.

The prototype is useful especially with a limited budget of time and money allocated.

This type of prototyping makes sure that a functioning model of the system is developed at an early stage of the development process, after a relatively short requirements analysis. Once the model is created, it is used as a benchmark for end-users to test and provide feedback on. Once the feedback has been received, this model is ‘thrown-away’ and a fully functioning system is developed, based on the feedback provided by the end-users.

2.1.2 Evolutionary Prototyping

Evolutionary prototyping is also known as breadboard prototyping. In this prototyping, the prototype is constructed in successive steps in order to understand the software problems and develop their solutions. The prototype is initially developed to satisfy few requirements. Then, gradually, the requirements are added to the prototype as better understanding of software system is reached. Once the prototype is developed it is used again and again. This process is repeated until all requirements are included in the prototype and the complete system is developed. Evolutionary prototyping involves the continuous tasks of refining and rebuilding of the prototype. Creating a solid prototype is the main aim of evolutionary prototyping and it is done through the incremental addition of system requirements. Evolutionary prototyping implies that requirements are not understood or defined completely at once at the start of the system design but are defined gradually. Evolutionary prototyping is built using those requirements that are well understood. This technique permits adding features, or making changes that are not well understood during the requirements and design phase.

The differences between evolutionary prototypes and throwaway prototypes include the following:

Evolutionary prototypes are functional systems while throwaway Prototypes are only temporary models of the system.

Evolutionary prototypes as part of the final system while throwaway prototypes are discarded after they are used.

Evolutionary prototypes are very robust prototypes while throwaway prototypes are simple prototypes.

In evolutionary prototyping, system developers focus on developing parts of the system that they understand completely instead of working on developing a whole system which they do not understand completely. To minimize risks, developers do not implement poorly understood features. Only well understood features are implemented. The partial system which is developed is reviewed, evaluated, and tested by users. Users use the system, based on user testing of the partial system, he/she defines new features and requirements and developers use these new features and requirements to improve the system.

2.1.3 Incremental Prototyping

In incremental prototyping technique developers first make a core part of the final product, and gradually complete developing the whole system. The final product is built as separate prototypes. At the end the separate prototypes are merged to form the overall design.

2.1.4 Extreme Prototyping

Extreme prototyping is used especially for developing Web applications. Basically, extreme prototyping technique breaks down Web development process into three phases, each one based on the preceding one. The three phases of the extreme prototyping are as follows:

The first phase is a static prototype that consists mainly of HTML pages of the Web application.

The second phase develops and programs the screens of the Web application. They become fully functional using a simulated services layer.

The third phase implements the services of the Web application.

The process is called extreme prototyping to draw attention to the second phase of the process, where a fully-functional user interface is developed with very little regard to the services.

3.1 Prototyping Tools

Efficiently using prototyping requires that an organization have proper tools and staff trained to use those tools. Tools used in prototyping can vary widely. Many organizations use multiple prototyping tools. Some use paper (Pictive) or white-board prototyping in the early stages of the requirements analysis that is based on user feedback. Once the requirements have been fully established, other, more advanced prototyping tools such as fourth generation languages (4th GLs) are used i.e. Visual Basic.

4GL tools are used for rapid prototyping. Other sophisticated software prototype tools include CASE Tools. Designer/developers use the actual tools/languages they use to build systems to create a system as a prototype. This prototype could still be either evolutionary or throw-away.

Although advanced prototyping methods such as fourth generation languages and CASE resemble the final version in a more detailed and sophisticated way, they do have the drawback of being expensive. This is why the use of the less advanced methods such as paper, particularly for the early stages is a more popular way of doing things. Also, many researchers and software developers believe that this way is a lot more productive as it allows designers and end-users to interact much frequently, compared to using CASE or 4th GLs. This is due to the fact that prototypes are made from paper cuttings, which can be created many times a day, each time there would be end-user feedback received. Prototyping is an iterative process and the iteration occurs much more when the paper prototypes are used.

In the following sub-sections we present some of these tools.

3.1.1 White-board Prototyping

In white-board prototyping users meet in a room with a big white board and then sketch out what a screen or report could look like, and then start changing it based on discussion and comments. White-boards are most useful in getting data requirements quickly. A white board could show a sample of data fields where users will quickly tell if they have the right data and tell what data is missing. Users can display usually one data entity, and then have a series of displays drawn. Finally, users will end up with a screen image version of a ER data model.

3.1.2 Fourth Generation Languages

Fourth generation languages such as Visual Basic and ColdFusion are commonly used in prototyping due to them being rather inexpensive. They are also commonly used as they are regarded as being easy to use and not too complicated to learn. They allow software engineers to generate executable code quickly.

3.1.3 Specification-level-Description Language

Specification-level description languages are used to construct a system prototype, which represents part of the system, including those necessary to meet the needs of users.

3.1.4 Case Tools

CASE tools are used to support requirements analysis. They are often developed or selected by large organizations.

3.1.5 Use Cases

A use case is a technique for documenting the potential requirements of a new system or software change. Use cases show how the system should interact with the end-user to attain a particular goal. Use cases are used to simplify a certain procedure/task that the user would be carrying out when using the system. It shows the behavior of the system as well as the user when interacting with one another. It illustrates all the possible ways of interaction.

3.1.6 Entity Relationship Diagrams

An Entity-Relationship Diagram (ERD) is a logical and abstract representation of the structured data for a system. It is a data oriented model of a system and does not provide any information regarding functionality of data. An entity-relationship diagram is named as such because it depicts data in terms of the entities and relationships described in the data.

Entity-relationship diagram is a relational schema database modeling method, used in software engineering to produce a type of conceptual data model (or semantic data model) of a system, often a relational database, and its requirements in a top-down fashion.

ERD has three main components:

Data entities

Data entities relationships

Data entities associated attributes

Data entity is most elementary component of a system about which data is to be maintained. Every entity has unique identity. It is represented by rectangular box with the name of entity written inside.

Data entities relationships connect entities to each other. They indicate how two entities are associated. They are represented by diamond notation with name of relationship written inside. Entity types that participate in a relationship is called degree of relationship. It can be one to one (or unary), one-to-many or many-to-many.

Figure 2 shows an example of an entity relationship diagram.

The cardinality of a relationship is the number of instances an entity has in regards to another entity. In Figure 2 the cardinality of the relationship is one to many between the two entities class and student.

class

class

Consists of

Figure 2: an example of an entity relationship diagram

The minimum cardinality of a relationship is the minimum number of instances of second entity with each instance of first entity.

Summary

In this lecture we present prototyping in software engineering. We first, present its definition, objectives, advantages and disadvantage. Then, we present sequence of prototyping in the software development life cycle. We also present the process of prototyping and its steps. We then, present types of the prototyping including throwaway prototyping, evolutionary prototyping, incremental, and extreme. We finally present prototyping tools including White-board, fourth generation languages, specification-level description language, CASE tools, use cases, and entity relationships diagrams.

Exercises

Define software e engineering prototyping.

List three advantages and three disadvantages of using prototyping.

List the steps of prototyping.

What are advantages of using throwaway prototyping over evolutionary prototyping?

What is the difference between incremental prototyping and extreme prototyping?

What is the advantage of 4GL tools over ER diagram?

Draw the sequence of prototyping in the software development life cycle.

Draw the ERD of the two entities: college and departments in a university.

Tutorial/Practical

You are asked to develop a prototype of a bookstore system using the entity-relationship diagrams. Identify all entities in this system. Then, draw all the entity-relationship diagrams of these entities with all relationships identified. Then, write a 5 page report to document this prototype.

Use two different types of prototypes.