Analysis of System Development Methods and Prototyping

This report delves into system development methodologies, defining them as a means of managing and standardizing the software development process. It emphasizes the importance of structured approaches for improved productivity and quality. The report then explores various prototyping methods used in the software industry, including rapid, evolutionary, incremental, and extreme prototyping. Rapid prototyping is described as a 'throwaway' method, while evolutionary prototyping builds upon an initial functional product. Incremental prototyping is presented as suitable for large enterprise software, and extreme prototyping is discussed in the context of web application development, outlining a three-stage process involving wireframes, functional HTML pages, and service layer code. The report provides a comprehensive overview of these methods, highlighting their characteristics and applications.

Task 1: System Development Methods
1. Define System development methodologies:
System development methods are advocated as a means of more effectively managing and controlling
the software development process, as well as organising and simplifying that process, and standardising
both the development process and the result. This is accomplished by outlining the activities that are to
be performed and the techniques that are to be employed. There is a widely held yet tacitly held idea
that using a methodical strategy throughout the creation of a system will result in increased productivity
and improved overall quality of output [1].
2. Name and describe the many methods of prototyping that are typically used in the software business
today:
The process of generating a simulated user interface during the development of software is referred to
as prototyping. The objectives of this process include ideation, evaluation, and the gathering of input
from actual users. The majority of modern software demos include some kind of user interaction as a
regular feature. They make an effort, to the best of their ability, to simulate the actual operation of the
software.
There are now four primary prototype approaches used in the software business, and they are as
follows:
1. Rapid prototyping using disposable materials:
Because its usefulness is anticipated to be limited to a short period of time, such as the duration of a
single sprint within the Agile development framework, the prototype that is produced by rapid
prototyping is frequently referred to as "throwaway prototyping." This is due to the fact that it can be
discarded after it has served its purpose. It is possible that it will go through numerous cycles of input,
alteration, and evaluation throughout that period of time. When all of the requirements of the
stakeholders have been satisfied, the document will then be available for the designers and developers
to utilise as a reference. After the time allotment for the sprint has been used up, the prototype is
discarded, and a new one is built in its place in order to be ready for the next sprint.

The phrase "throwaway prototyping" may also be used to refer to the creation of prototypes at a more
leisurely pace. Due to the nature of the process, paper prototypes, in which the designs are copied on
pieces of paper or cardboard, are seen as "throwaway." Computer files, regardless of whether they are
visuals that are static or prototypes that are interactive, will ultimately end up on someone's hard drive
for forever. This is true even if it is often the case that they are never needed once the development
cycle has been completed.
2. prototyping via evolutionary processes:
A software prototype is often little more than a simulation, whereas an evolutionary prototype is an
actual piece of software that is fully operational. To begin the process of producing an evolving
prototype, the first thing that must be done is to produce a product that fulfils the requirements of the
whole system. A good place to start, but it won't be enough to satisfy all of the requirements of the
client. There is the potential for additional features and capabilities to be deployed if and when it
becomes clear that the stakeholders need them. This is because the nature of this prototype might be
described as "evolutionary."
The initial version of an evolutionary prototype may be compared to the minimal viable product (MVP),
which is a term used to describe a piece of software that only has the functionality that are absolutely
essential for it to be of any value. The procedure that is utilised to define the criteria for that initial
version is where the most significant difference may be found.
3. Prototyping with incremental iterations:
Incremental prototyping might be useful for enterprise software that consists of a large number of
modules and components that are only loosely coupled to one another, since this kind of software often
has many moving parts. The process of building a number of separate, more compact prototypes in
parallel is referred to as incremental prototyping. Following the examination and improvement of the
individual prototypes in isolation, they are integrated into a more complete whole. This entire is then
put through another round of review to see whether or not it retains a consistent look, behaviour,
language, and texture.
When incremental programming is used, there is always a chance that the look and feel of the many
prototypes will shift to such a great extent that the individual modules will give the impression of being
whole new pieces of software. This is because the many prototypes will be built on top of each other. In
order to ensure that there is coherence across the product, the team responsible for the design has to
determine specific guiding principles in advance and keep the designers under close supervision.

4. The most extreme kind of prototyping:
When it comes to the development of web apps, extreme prototyping is becoming more common.
Extreme prototyping is a procedure that is comprised of the following three stages:
• Construct wireframes using HTML as a proxy for the presentation layer of your application. These
websites only provide a little degree of user interaction via their content, if any at all. They are
comprehensive enough to show users the many routes that they may take while navigating the
application, which is something that they are able to do.
• As part of the process, convert the wireframes into fully functional HTML pages and link them to a
simulated services layer. This must be done before proceeding.
• First write some code for the services layer, and then put that code into action.
This technique is known as a "extreme" approach because it involves the planning and construction of
the user interface before any of the underlying technology is deployed. This is the primary reason for
this strategy's reputation as a "extreme" method. After that point, the authors of the services are the
ones responsible for ensuring the functioning of the whole thing [2].