Tag Archives: RAD

Rapid Application Development: MoSCoW Prioritisation

Posted in Agile Software Development, Information Systems Engineering by

To be successful projects need to be properly prioritized for both the requirements and the main project objectives. One mechanism is to use a number system, but this is flawed as it results in all elements being number one. A more useful method is to use a set of words that have meaning such as the MoSCoW method. However to be effective prioritization requires hard choices to be made.

MoSCoW Prioritasation

MoSCoW Prioritasation

Prioritisation of Requirements

An important factor for the success of any project is ensuring that the requirements, are prioritised. In many cases this is not done leading to sure project failure. Sometimes it is the customers’ fault who want the entire system to be delivered now. Other times it is the project manager’s fault because they do not discuss the project with the customer. In either case prayers for miracles are often required if the project is to have any chance of being successful. In my experience miracles rarely happen on projects.

However prioritising is not an easy process, and even less so when done using a number system. The trouble with number systems is that it appears logically to give the features a priority of 1, 2, 3 etc. However who wants a requirement to be a “2” or even a “3”? As a result all requirements become a “1”, which is useless. This can lead to having to resort to additional systems such as giving “1*” and “1**” ratings to try to sort out what is really important. Even this is subject to prioritisation drift – upwards.

Even more damaging with number systems is that features that will not be developed this time are left off the list, and are ultimately lost. This means that designers and developers are unaware of these future needs, and therefore cannot select solutions which will make it easier to accommodate them at a later date.

So effective prioritisation is important but how can it be done if number systems are not effective?

MoSCoW

A more successful method is to prioritise requirements by using words that have meaning. Several schemes exist but a method popularised by the DSDM community is the acronym MoSCoW. This stands for:
M – MUST have this.
S – SHOULD have this if at all possible.
C – COULD have this if it does not effect anything else.
W – WON’T have this time but would like in the future.
The two lower case “o” are there just to make the acronym work. The importance of this method is that when prioritising the words mean something and can be used to discuss what is important.

The “Must” requirements are non-negotiable, if they are not delivered then the project is a failure, therefore it is in everybody’s interest to agree what can be delivered and will be useful. Nice to have features are classified in the other categories of “Should” and “Could.

“Must” requirements must form a coherent set. They cannot just be “cherry picked” from all the others. If they are then what happens is that by default all the other requirements automatically become “Must”, and the entire exercise is wasted.

Requirements marked as “Won’t” are potentially as important as the “Must” category. It is not immediately obvious why this is so, but it is one of the characteristics that makes MoSCoW such a powerful technique. Classifying something as “Won’t” acknowledges that it is important, but can be left for a future release. In fact a great deal of time might be spent in trying to produce a good “Won’t” list. This has three important effects:

  • Users do not have to fight to get something onto a requirements list.
  • In thinking about what will be required later, affects what is asked for now.
  • The designers seeing the future trend can produce solutions that can accommodate these requirements in a future release.
Prioritising the Project Objectives

When a set of requirements has been prioritised then it can be compared against the other planning aspects of project: scope, quality, timescale and resources, and a risk statement produced.

There is a general wish among managers to be able to decide when a project will be delivered, how much it will cost and what it will do. They then think they have removed all the degrees of freedom, and as they have made an assertion, reality will follow their thinking.

Reality will not, as they have left out two significant factors. The first is quality; it may be delivered on time but the quality is appalling. It does what the requirements say, but the system is not robust enough to be used by anybody, as one mistake will make it crash. The other factor is risk, which may be so sky high, that project failure has guaranteed before it starts.

One suggestion is to prioritise the four main factors of scope, quality, timescale and resources, and thus prioritise the key project objectives. Which of them “Must” be delivered, which has the maximum flexibility and is defined as “Could”, with the other two factors between these as “Should”. This means that at least one factor can be allowed to slip, and provide flexibility for setting a proper risk plan to ensure the essential factor is met. This is not losing control, it is acknowledging that building a piece of software is a trip into the unknown, and precautions need to be taken.

Implications of Prioritising the Project

Selecting the right prioritisation order of is not easy. Any choice that is made has tradeoffs.

If nearly all the requirements are prioritised as “Must”, then there is not much flexibility in the scope of a project. By definition the scope is the “Must” factor in the project and a decision has to be taken either about which of the others will have flexibility, or which of the requirements will be down graded from a “Must”.

However many studies have shown that it is better if a project is delivered on time, even if it has few features, than if a project is delivered late, but with a full set of features. This can be likened to saying when is the best time to deliver Christmas crackers to shops, before or after Christmas? Therefore timescale competes to be the most important factor.

If quality is sacrificed then faults will occur in the software. One way around this is to train the users in the use of a new system, so that they only use it in proper fashion, and know how to get around any bugs that are discovered. However if it is an Internet system intended to be used by customers, then this cannot be done, and a reputation damage to the organisation may result, due to a faulty system.

Finally all systems must be produced to a budget, and a business does not have unlimited resources to put into a project. Moreover the business case normally assumes a rate of return, which will be considerably reduced if the resources are increased significantly on a project. Therefore resources have a strong case for being the most important factor.

Regardless you cannot “have it all and have it now”, and a balanced and planned prioritisation of the factors must take place if a project is to have a chance of delivering business value. If it is not then the fifth factor of risk goes sky high, and ceases to be risk and become inevitable.

Source

Advantages and Disadvantages of Rapid Application Development (RAD)

Posted in Agile Software Development, Information Systems Engineering by
Advantages of RAD Software Development
  • The time required to develop the software is drastically reduced due to a reduced requirement analysis business requirements documentation and software requirement specification) and planning stage.
  • All the software prototypes produced can be kept in a repository for future use. The re-usability of the components also enhances the speediness of the process of software development.
  • It is much easier for a project manager to be accurate in estimating project costs which of course means that project cost controls are easier to implement and manage as well.
  • It is a big cost saver in terms of project budget as well as project time and cost due to re-usability of the prototypes.
  • If a component is being picked for the repository, it is already tested and hence need not be tested again. This helps in saving time required for testing.
  • The project management requirements are collected in a dynamic manner. Every time there is a prototype ready, requirements are studied and matched. If there are any additional requirements, these are then included in the next prototype built.
  • There is a strong and continuous participation of the project sponsor who keeps giving feedback in the whole process. Hence the end user satisfaction level is higher when the end result is produced.
  • It promotes better documentation through written test cases.
Disadvantages of RAD Software Development
  • This method may not be useful for large, unique or highly complex projects
  • This method cannot be a success if the team is not sufficiently motivated and nor is unable to work cohesively together.
  • Success depends on the extremely high technical skills of the developers.
  • There are times when the team ignores necessary quality parameters such as consistency, reliability and standardization. Hence this can make project quality management hard to implement during the project management life cycle

Source

General Characteristics of Rapid Application Development (RAD)

Posted in Agile Software Development, Information Systems Engineering by

Rapid Application Development Methodology

Incremental development

An important element of the philosophy of RAD is the belief that not all a system’s requirements can necessarily be identified and specified in advance. Some requirements will only emerge when the users see and experience the system in use, others may not emerge even then, particularly complex ones. Requirements are also never seen as complete but evolve and change over time with changing circumstances . Therefore, trying fully to specify a system completely in advance is not only a waste of time but often impossible. So why attempt to do it? RAD starts with a high-level, rather imprecise list of requirements, which are refined and changed during the process, typically using toolsets . RAD identifies the easy, obvious requirements and, in conjunction with the 80/20 rule , just uses these as the starting point for a development, recognizing that future iterations and timeboxes (see below) will be able to handle the evolving requirements over time. Hough (1993) suggests using the technique of functional decomposition and each function identified and the requirements listed, but, he says,

the precise design specifications, technical issues, and other concerns should be deferred until the function is actually to be developed

Time-boxing

The system to be developed is divided up into a number of components or timeboxes that are developed separately. The most important requirements, and those with the largest potential benefit, are developed first and delivered as quickly as possible in the first time box. Some argue that no single component should take more than 90 days to develop, while others suggest a maximum of six months. Whichever timebox period is chosen, the point is that it is quick compared with the more traditional systems development timescale.

Systems development is sometimes argued to have three key elements. In tradi- tional development two are typically variable: time and resources (see Figure 6.3). In traditional development when projects are in difficulty, either the delivery time is extended or more resources are allocated or both but the functionality is treated as fixed. In RAD the opposite applies, resources and time are regarded as fixed (allocating more resources is viewed as counterproductive although this does sometimes happen), and so that only leaves functionality as a variable. So, under pressure and when projects are in difficulty, time and resources remain constant but the functionality is reduced.

Traditional development -time and resources

Figure 1.1: Traditional development -time and resources

RAD compartmentalizes the development and delivers quickly and often. This provides the business and the users with a quick, but it is hoped, useful part of the system in a refreshingly short timescale. The system at this stage is probably quite limited in relation to the total requirements, but at least something has been delivered. This rapid delivery of the most important requirements also helps to build credibility and enthusiasm from the users and the business. Often for the first time they experience a system that is delivered on time. This is radically different from the conventional delivery mode of most methodologies which is a long development period of often two to three years followed by the implementation of the complete system. The benefits of RAD development is that users trade off unnecessary (or at least initially unnecessary) requirements and wish lists (i.e. features that it would be ‘nice to have’ in an ideal world) for speed of development. This also has the benefit that, if requirements change over time, the total system has not been completed and each timebox can accommodate the changes that become necessary as requirements change and evolve during the previous timebox. It also has the advantage that the users become experienced with using and working with the system and learn what they really require from the early features that are implemented.

Comparison of timebox development and traditional development

Figure 1.2: Comparison of timebox development and traditional development

Figure 1.2 illustrates three chunks of development and, although the overall time to achieve the full implementation could be the same as with a .traditional development, the likelihood is that the system actually developed at the end of the three timeboxes will be radically different from that developed at the end of one large chunk as a result of the learning and evolving processes which leads to change being made to each specification at the beginning of each timebox.

Some RAD proponents argue that, if the system cannot be divided into 90 day timeboxes, then it should not be undertaken at all. Obviously such an approach requires a radically different development culture from that required for traditional or formalized methodologies. The focus is on speed of delivery, the identification of the absolutely essential requirements, implementation as a learning vehicle, and the expectation that the requirements will change in the next timebox. Clearly such radical changes are unlikely to be achieved using conventional techniques.

Once the duration of the timebox has been decided it is imperative that the system is delivered at the end of it without slippage, as timeboxes are fixed. So how is this achieved? Well, first, by hard work and long hours and, secondly, by the use of the other RAD techniques discussed below. But also if slippage is experienced during development of a timebox then the requirements are reduced still further (i.e. some of the things that the system was going to do will be jettisoned).

The Pareto principle

This is essentially the 80/20 rule and is thought to apply to requirements. The belief of RAD proponents is that around 80 per cent of a systems’ functionality can be delivered with around 20 per cent of the effort needed to complete 100 per cent of the requirements. This means that it is the last, and probably most complex, 20 per cent of requirements that take most of the effort and time. Thus why do it? – just choose as much of the 80 per cent to deliver as possible in the timebox, or at least the first timebox. The rest, if it proves necessary, can be delivered in subsequent time boxes.

MoSCoW rules

In RAD the requirements of a project are prioritized using what is termed the MoSCoW Rules:

  •  M = ‘the Must Haves’. Without these features the project is not viable (i.e. these are the minimum critical success factors fundamental to the project’s success).
  • S = ‘the Should Haves’. To gain maximum benefit these features will be delivered but the project’s success does not rely on them.
  • C = ‘the Could Haves’. If time and resources allow these features will be delivered but they can easily be left out without impacting on the project.
  • W = ‘the Won’t Haves’. These features will not be delivered. They can be left out and possibly, although not necessarily, be done in a later timebox.

The MoSCoW rules ensure that a critical examination is made of requirements and that no ‘wish lists’ are made by users. All requirements have to be justified and categorized. Normally in a timebox all the ‘must haves’ and at least some of the ‘should haves’ and a few of the ‘could haves’ would be included. Of course, as has been mentioned, under pressure during the development the ‘could haves’ may well be dropped and even possibly the ‘should haves’ as well.

JAD workshops

RAD requires high levels of participation from all stakeholders in a project as a point of principle and achieves this partly through the JAD workshop. JAD (Joint Application Development) is a facilitated meeting designed to overcome the problems of traditional requirements gathering (see Section 16.2), in particular interviewing users. It overcomes the long time that the cycle of interviews take by getting all the relevant people together in a short period to hammer out decisions. Normally in the context of RAD, a JAD workshop will occur early on in the development processto help establish and agree the initial requirements, the length of the timebox, what should be included and what excluded from the timebox, and most importantly to manage expectations and gain commitment from the stakeholders. Sometimes a subsequent JAD workshop is used to firm up on the details of the initial requirements, etc. In some RAD approaches the whole process is driven by a series of JAD meetings that occur throughout the timebox.

The fourth element is the presence of an executive sponsor. This is the person who wants the system (or whatever the focus of the meeting is), is committed to achieving it and is prepared to fund it. This person is usually a senior executive who understands and believes in the JAD approach and who can overcome the bureaucracy and politics that tend to get in the way of fast decision making that usually bedevils traditional meetings

Prototyping

Prototyping is an important part of RAD and is used to help establish the user requirements and in some cases the prototype evolves to become the system itself. Prototyping ;helps speed up the process of eliciting requirements, and speed is obviously important in RAD, but it also fits the RAD view of evolving requirements and users not knowing exactly what they want until they see or experience the system. Obviously the prototype is very helpful in this respect.

Sponsor and Champion

Having a committed sponsor and a champion of the systems is an important requirement for RAD and for its success. We have discussed the sponsor above. A champion is someone, often at a lower level of seniority, who is also committed to the project, who understands and believes in RAD, and is prepared to drive the project forward and overcome some of the bureaucracy and politics.

Toolsets

RAD usually adopts, although not necessarily, the use of toolsets to help speed up the process and improve productivity. In general it is usually argued that the routine and time-consurning tasks can be automated as well as using available tools for change control, configuration management, and even code reuse. Reuse of code is another way that RAD speeds the development process. However, it is not just about speed but also quality because existing code or modules have usually already been well tested, not just in development, but in real use. RAD searches for shortcuts and reuses code, maybe clones existing code and modifies it, or utilizes commercial packages, etc. where applicable. This may be code within the organization or bought from outside. Sometimes more than just a little piece of code is used; for example, complete applications may be used and the developers use this as the basis of the new system and change the interface to produce the desired results. Many ‘new’  e-commerce or Internet applications have been developed in this way using the legacy systems and then providing a new ‘umbrella’ set of applications and user interfaces on top. The idea is to leverage existing code, systems, experience, etc.

Specific RAD productivity tools have been around for some time and are developing fast, and existing tools and languages are being enhanced for RAD, particularly for rapid development of Internet and e-business based applications.

Source

  • David Avison & Guy Fitzgerald, 2006. Rapid application development (RAD). In David Avison & Guy Fitzgerald Information Systems Development. 4th ed. Pearson Education Limitied. Ch. 7. pp.128-132.ISBN-13 978-0-07-711417-6

Rapid Application Development Methodology

Posted in Agile Software Development, Information Systems Engineering by

A method of developing information systems which users prototyping to achieve user involvement and faster development compared to traditional methodologies such as SSADM.
Professor Clifford Kettemborough of Whitehead College, University of Redlands,
defines

Rapid Application Development as an approach to building computer
systems which combines Computer-Assisted Software Engineering (CASE) tools and techniques, user-driven prototyping, and stringent project delivery time limits into a potent, tested, reliable formula for top-notch quality and productivity. RAD drastically raises the quality of finished systems while reducing the time it takes to build them.

Online Knowledge defines

Rapid Application Development as a methodology that
enables organizations to develop strategically important systems faster while reducing
development costs and maintaining quality. This is achieved by using a series of
proven application development techniques, within a well-defined methodology.

History

Rapid application development is a term originally used to describe a software development process introduced by James Martin in 1991. Martin’s methodology involves iterative development and the construction ofprototypes. More recently, the term and its acronym have come to be used in a broader, general sense that encompasses a variety of methods aimed at speeding application development, such as the use of software frameworks of varied types, such as web application frameworks.

RAD vs. Waterfall

In the 1970s and 1980s, several sequential software engineering processes were developed that regarded application development as flowing steadily downward through the different phases of the development process.

Traditional development vs. Rapid Application Development

Traditional development vs. Rapid Application Development

The first description of such a waterfall model is often cited in an article published in 1970 by Winston W. Royce2. However, in this article, Royce presented the model as an example of a flawed, non-working approach. “Waterfall” has in later years become a common term to criticize traditional software development practices. The problem with most waterfall models is the fact that it relies on a methodical requirements analysis phase alone to identify all critical requirements for the application. There is ample evidence that projects using a waterfall approach often fail to provide a useable end product; because projects often exceed their deadlines, the product either fails to meet all requirements or the requirements change during the protracted development phase.

There have been many responses to this problem from the 1980s to today, but almost all of those responses focus on the idea of developing systems in a short timeframe with small teams of highly skilled and motivated staff. It is the iteration step that solves the problems inherent to the inflexible approach of traditional software development.

Why was needed to invent RAD?

The evidence from project failures for projects in the 1980s and 1990s, as evidenced for example by the Standish Group Chaos report (1995), implies that traditional structured methodologies have a tendency to  deliver systems that arrives too late and therefore no longer meet their original requirements. Traditional methods can fail in a number of ways.

  • A gap of understanding between user and developers: Users tend to know less about what is possible and practical from the a technology perspective, while developers may be less aware of the underlying business decision -making issues which lie behind the systems development requirement.
  • Tendency of developers to isolate themselves from users: Historically, systems developers have been able to hide behind  a wall of jargon, thus rendering the user community at an immediate disadvantages when discussing IS/IT issues. While some jargon may be necessary if points are to be made succinctly, it is often used to obscure poor progress with a particular development project.  The tendency for isolation is enhanced by physical separation of some computer staff in their air-conditioned computer rooms. Developers might argue in their defence that users also have their own domain-specific jargon which adds to the problem of deciphering requirements.
  • Quality measured by closeness of product to specification: This is a fundamental difficultly – the observation that ‘ the system does exactly what the specification said it would so’  hides the fact that the system may still not deliver the information that the users need for decision-making purpose. The real focus should be on a comparison of the deliverables with the requirements, rather than of  deliverables  with a specification that was a reflection of a perceived need at a particular point in time.
  • Long development times: SSADM and the waterfall model will reveal that the process of analysis and design can be very laborious and time-consuming. Development times are not helped by the fact that and organization may be facing rapidly changing business conditions and requirements may similarly be changing. There is a real risk of the ‘moving goal-post’  of syndrome causing havoc with a traditional approach to systems development.
  • Business needs change during the development process: This is alluded to above. A method is needed where successive iterations in the development process are possible so that the latest requirements can be incorporated.
  • What users get isn’t necessarily what the want: The first a user may see of a new information system is at the testing or traning stage. At this point , it will be seen whether the system as delivered by the IS/IT professionals in what the user acually needs. An appropriate analogy here is the purchase of a house or car simply on the basis of discussions with an estate  or a garage agent  rather than by actually visiting the house or driving the car. It is unlikely that something purchased  in this way will result in a satisfied customer and there in no reason to suppose that information systems developed is a similar way will be any more successful.
Rapid Application Development Model

Rapid Application Development Model

Not only is there pressure from end-user management for faster systems development, IS/IT department themselves increasingly recognize the need to make more effective use of limited human resources within is their departments while at the same time quickly delivering systems that confer business benefits. All this is is a climate of rapid business change and therefore, rapidly changing information needs. Rapid Application Development (RAD) is a method possible solution to these problems and pressures.

Is RAD  appropriate for all projects?

The Rapid Application Development methodology was developed to respond to the need to deliver systems very fast. The RAD approach is not appropriate to all projects – an air traffic control system based on RAD would not instill much confidence. Project scope, size and circumstances all determine the success of a RAD approach. The following categorize indicates suitability for a RAD approach:

Project Scope
Suitable for RAD – Focused scope where the business objectives are well defined and narrow.
Unsuitable for RAD – Broad scope where the business objectives are obscure or broad.

Project Data
Suitable for RAD – Data for the project already exists (completely or in part). The project largely comprises analysis or reporting of the data.
Unsuitable for RAD – Complex and voluminous data must be analyzed, designed and created within the scope of the project.

Project Decisions
Suitable for RAD – Decisions can be made by a small number of people who are available and preferably co-located.
Unsuitable for RAD – Many people must be involved in the decisions on the project, the decision makers are not available on a timely basis or they are geographically dispersed

Project Team
Suitable for RAD – The project team is small (preferably six people or less).
Unsuitable for RAD – The project team is large or there are multiple teams whose work needs to be coordinated.

Project Technical Architecture
Suitable for RAD – The technical architecture is defined and clear and the key technology components are in place and tested.
Unsuitable for RAD – The technical architecture is unclear and much of the technology will be used for the first time within the project.

Project Technical Requirements
Suitable for RAD – Technical requirements (response times, throughput, database sizes, etc.) are reasonable and well within the capabilities of the technology being used. In fact targeted performance should be less than 70% of the published limits of the technologies.
Unsuitable for RAD – Technical requirements are tight for the equipment to be used.

General Characteristics of Rapid Application Development (RAD)

   Sources

Managing the prototyping process in DSDM

Posted in Agile Software Development by

This section discusses a number of key issues that surface in the management of the prototyping process.

Managing iteration

There are several aspects that have to be managed in order to achieve successful passage through prototyping
activities. These are:

  • timeboxing
  • change control
  • configuration management
  • user involvement
  • quality assurance of products
  • learning from earlier iterations.

Strict adherence to timeboxes ensures that prototyping cycles are not allowed to lose their focus on delivering to the agreed priorities and that the quality of products is assessed within each timebox.

The procedures for change control must enable change to be introduced quickly and effectively. Over-prescriptive procedures will slow down development.

In order to be able to backtrack to a previous prototype, strong configuration management must be enforced. For instance, users may decide that a previous user interface was preferable to the current one or that the functionality is
progressing in the wrong direction to meet their most immediate business needs. In such circumstances, it must be possible to move backwards smoothly and for all developers to be sure of which version or variant is the current one.

While prototyping without user involvement is impossible, it is important that the users do not drive the development in the wrong direction through lack of knowledge outside their own sphere of activities. Senior user management must
ensure that a representative set of users is included in prototyping activities.
To ensure that prototyping progresses as fast as possible, it is important that the selected user representatives are available at all times when they are needed.
By keeping the team consistent throughout development, the team can learn from previous prototyping activity and so improve the quality of the products and the efficiency of working.
The number of iterations
As a general rule, it is recommended that three iterations be allowed – and that they are aligned to the timebox process:
  • investigation to see whether the right approach is being taken
  • refinement to build on the comments and feedback after the investigative prototype
  • consolidation to fully satisfy the objectives of the prototype.

This will mean three prototype cycles leading to a part of the Functional Model and three prototype cycles leading to a part of the Tested System. However, if the nature of the application and/or the technical environment mean that functional modelling and design and build merge then the number of prototypes will obviously be reduced. It is generally advisable to avoid more than three iterations since this can encourage a feeling that things can be left until later.

Collaboration and consensus

Prototyping requires collaboration and consensus between the developers and the users, as distinct from a contract negotiated at the start of the process, which can frequently be a source of confrontation between developers and users.

Choosing what to prototype

When producing the Development Plan, the project manager and the team decide where the categories of prototypes (and any combinations of them) are most appropriate, given the business and technical environment.

Horizontal vs. vertical approach

Having chosen the area to prototype, the DSDM team must first choose whether to build their prototypes in a horizontal or a vertical way. The choice is simply a way of slicing up the application, so any category of prototype may appear in a
horizontal or a vertical application slice.

With a horizontal approach the whole system is first built at a high level to check how it will cover the scope of the project. The detail is filled in later. With a vertical approach a section of the computer system is built incrementally until
it is fully understood, then the next section is started.

Both approaches have their advantages and disadvantages. If the whole concept of the system/business area is new then a horizontal approach may be safer. If the overall structure of the system is well understood but the detail is unclear then a vertical approach might be better. One advantage of the vertical approach is that it allows incremental deployment of subsystems for immediate business benefit. Generally, systems will be built using a combination of  horizontal and vertical approaches.

Source:

Categories of prototypes as recommended by DSDM

Posted in Agile Software Development by

Dynamic Systems Development Method (DSDM) is a framework for delivering business solutions that relies heavily upon prototyping as a core technique, and is itself ISO 9001 approved. DSDM uses the word ‘prototyping’ because that is the industry ‘standard’, but they are not truly prototypes: they are partial system components. A DSDM prototype is not ‘all done by mirrors’, but is built using the platform on which all the development work is done, and meeting all the required  standards. In other words, the prototypes are intended to be evolutionary {may be evolved horizontally (breadth then depth) }rather than throwaway {each section is built in detail with additional iterations detailing subsequent sections}: they will evolve into the delivered system. Of course, there will be occasions when it is better to throw something away and start again, but the aim at all times should be to build on what is there already.

Four categories of prototype are recommended by DSDM that are used at different stages of development, and have very different purpose. They are:

  • Business prototypes
  • Usability prototypes
  • Performance and capacity prototypes
  • Capability / design prototypes

While the purpose of each prototype category is different, it will often be the case that some combination of them will be used. For instance, a common combination is the business and usability prototype, but this approach should not be taken as a matter of course. If the functionality is at all complex, it may be better to get it right before worrying about the presentation aspects. Conversely, if there is no standard for user interface design, it is good idea to get some usability prototyping done first. The categories of prototype to be built in a timebox should be decided at its outset based on the aims of the timebox.

Business prototypes

  • Purpose:
    A business prototype demonstrates the developers’ understanding of the functional requirements. The developers can use this prototype to demonstrate to the users how the final system could work. This will enable the users to better formulate their real business requirements.
  • Description:
    A business prototype is designed only to demonstrate how the business processes are supported by the computer system. It is not designed to look good or to be particularly user-friendly: nor will secondary functionality, such as error checking, necessarily be implemented. It is very important that the users understand the purpose of demonstrating a business prototype.
  • How used:
    A business prototype enables the developers to demonstrate to the users their understanding of the key system requirements early in the project. This early prototype can then be evolved to cover more of the functionality and to incorporate non-functional aspects. Typically, the developer will use a scripted demonstration to ensure that the functionality is demonstrated to best effect. Any discrepancies between the developers’ understanding and the business requirements are noted.
  • Position in the project lifecycle :
    The first business prototype will be demonstrated as early as possible in the project lifecycle (possibly as early as the Feasibility Study, but no later than early in the Functional Model Iteration). This will confirm the right system is being built. First, the fundamental functionality of the system will be demonstrated. Later on, more detailed functional requirements can be demonstrated and/or other areas can be business prototyped.The final business prototype will clearly demonstrate to the users how the system will work. It may not look very pleasing, and have lots of missing functionality, but it will ensure the right system is being built.
Usability prototypes
  • Purpose: A usability prototype ensures the computer system will be as easy and intuitive to use as possible. Users should enjoyusing the system and it should be obvious how the system can be used. If this is done well, end-users will need less training before they can use the system effectively, while still having a good understanding of the full capabilities of the system.
  • Description:
    Well-designed computer systems are simple and straightforward, easy to learn and understand, and fun to use. It is impossible to achieve usability without trying the system out on the users. A usability prototype demonstrates how the user interacts with the system. It may not actually automate the business process. For example a form is displayed, the user adds data, but nothing is written to disk. The user can understand how to move around the system and how the  interface works.
  • How used:
    A user carries out a number of tasks using the prototype.  Any difficulties encountered by the user in achieving those tasks are noted so that the usability of the system can be improved.Contrast this with the business prototype where the developer will typically demonstrate the system, to show the functionality only. A business prototype may be rather user-unfriendly so it is better if the developer removes the need for a user to learn the interface.There is a danger of building a usability prototype that cannot be developed into the final system. Developers must take care not to create any unrealistic expectations.
  • Position in the project lifecycle:
    usability prototype may be built during either the Functional Model Iteration or the Design and Build Iteration, but there are many benefits in building it as early as possible. For a computer system to be easy to use, it must have a simple conceptual  model that the users can easily understand to help them move around the system.
    A usability prototype confirms that a good conceptual model has been chosen. If this is not done early on in the project and the model is wrong, it could adversely affect the design of the system. To reduce the risk of this, a high-level usability prototype should be built in the Functional Model Iteration or early on in the Design and Build Iteration. More detailed usability, such as the buttons in a window, can be designed later. If standards for the user interface are chosen early on, then all programs can be built to the agreed standard, reducing the need for rework. Having a stable installation Style Guide in place before prototyping commences on any project would help even more.In practice there are many benefits in combining the business and usability prototypes.
Performance and capacity prototypes
  • Purpose:
    A performance and/or capacity prototype ensures that the final computer system will be able to handle the full peak time workload required. While users may be involved, this category of prototype is typically for the benefit of the developers.
  • Description:
    This prototype deals with the non-functional aspects of the system, such as concurrent transaction volumes, data loading, overnight batch reports, and month end batch runs, as well as on-line screen performance. Checks will be made that the target system has enough resources to function adequately in the live environment, even when other systems are competing for machine resources.
  • How used:
    Performance and capacity prototypes are usually developed for the benefit of the developers to ensure the computer system can meet its desired performance requirements. A test scenario is set up and repeated while changing different aspects of the system to see how it performs. This process is best automated so that it is easily repeated, but it can be
    done manually where a group of users follow a script. The system is monitored to see where any “bottlenecks” occur.
  • Position in the project lifecycle:
    This category of prototype is typically used during Design and Build Iteration, after the required functionality has been determined. Often existing business prototypes will be used for performance testing. Sometimes early in the project design, the developers may be concerned as to whether a certain piece of functionality can be provided within the
    constraints of the machine/network environment. In this case, a performance and capacity prototype can be specially built to check where the limits might be. Such a prototype might look very different from the final system.
Capability/technique prototypes
  • Purpose:
    Developers often have a range of design options and sometimes a choice of tools to use. A capability/technique prototype tries out a particular design approach or tool to help in choosing between these options.
  • Description:
    This category of prototype is typically limited in functionality and is for the benefit of the developers only. The prototype demonstrates the capabilities and limitations of an approach, a technique or a tool to the developers.
  • How used:
    The developer builds a number of prototypes and weighs up the benefits of each technical approach.
  • Position in the project lifecycle:
    Although selection of a tool is usually made outside any one particular project, a tool capability prototype can be developed during the Feasibility Study to ensure that the potential technical approach will be soundly based. Later design capability/technique prototypes are created during the design phase of a project.Different designs or tools are used to build prototypes that represent the options available to the developer. Each prototype can then be assessed and the best approach, technique or tool selected.
Sources: