UNIT-II
- Process of Software
Topics:
·
Software Engineering
·
Software Process
·
The Waterfall Model
·
Incremental Process Models
·
Evolutionary Process Models
·
Spiral Model
Software
Process:
The
software process is represented schematically in Figure 2.1. Referring to the
figure, each framework activity is populated by a set of software engineering
actions. Each software engineering action is defined by a task set that
identifies the work tasks that are to be completed, the work products that will
be produced, the quality assurance points that will be required, and the
milestones that will be used to indicate progress.
A
generic process framework for software engineering defines five framework
activities—communication, planning, modeling, construction, and deployment. In
addition, a set of umbrella activities—project tracking and control, risk
management, quality assurance, configuration management, technical reviews, and
others—are applied throughout the process.
The
Waterfall Model:
Sometimes
called the classic life cycle or the waterfall model, the linear sequential
model suggests a systematic, sequential approach to software development that
begins at the system level and progresses through analysis, design, coding,
testing, and support. The linear sequential model encompasses the following
activities:
Communication
Because
software is always part of a larger system (or business), work begins by
establishing requirements for all system elements and then allocating some
subset of these requirements to software. This system view is essential when
software must interact with other elements such as hardware, people, and
databases.
Planning:
In planning major activities like planning for
schedule, keeping tracks on the processes and the estimation related to the
project are done. Planning is even used to find the types of risks involved
throughout the projects.
Design/Modeling:
Software
design is actually a multistep process that focuses on four distinct attributes
of a program: data structure, software architecture, interface representations,
and procedural (algorithmic) detail. The design process translates requirements
into a representation of the software that can be assessed for quality before
coding begins. Like requirements, the design is documented and becomes part of
the software configuration.
Code
generation:
The
design must be translated into a machine-readable form. The code generation
step performs this task. If design is performed in a detailed manner, code
generation can be accomplished mechanistically
Deployment:
Software
will undoubtedly undergo change after it is delivered to the customer. Change
will occur because errors have been encountered, because the software must be
adapted to accommodate changes in its external environment, or because the
customer requires functional or performance enhancements. Software
support/maintenance reapplies each of the preceding phases to an existing
program rather than a new one.
Incremental
Process Models
Incremental Process Models
are software development methodologies that involve dividing the project into
small, manageable parts or increments. Each increment represents a portion of
the complete system's functionality, and development occurs incrementally, with
each increment building upon the previous ones. This approach allows for the
delivery of partial but usable versions of the software throughout the
development process.
When
an incremental model is used, the first increment is often a core product. That
is, basic requirements are addressed but many supplementary features (some known,
others unknown) remain undelivered. The core product is used by the customer
(or undergoes detailed evaluation)
The
incremental process model focuses on the delivery of an operational product with
each increment. Early increments are stripped-down versions of the final product,
but they do provide capability that serves the user and also provide a platform
for evaluation by the user.
Incremental
development is particularly useful when staffing is unavailable for a complete
implementation by the business deadline that has been established for the project.
Early increments can be implemented with fewer people. If the core product is
well received, then additional staff (if required) can be added to implement
the next increment.
Incremental
development is particularly useful when staffing is unavailable for a complete
implementation by the business deadline that has been established for the project.
Evolutionary
Process Models
Evolutionary
models are iterative. They are characterized in a manner that enables you to
develop increasingly more complete versions of the software. In the paragraphs
that follow, I present two common evolutionary process models
THE
PROTOTYPING MODEL:
Evolutionary Process Models are
software development methodologies that prioritize flexibility and adaptability
in response to changing requirements. These models recognize that software
development is an iterative and incremental process, and they emphasize
continuous refinement and improvement of the software throughout its
development life cycle. Two common types of Evolutionary Process Models are the
Prototyping Model and the Spiral Model.
·
Communication/Requirements Gathering:
Initial
requirements are gathered through discussions with stakeholders. However, these
requirements are expected to be incomplete or vague at this stage.
·
Quick Design and Construction:
A quick design
is created based on the initial requirements, and a prototype is developed. The
prototype is a working model of the software that may not have all the features
but provides a visual representation of the user interface and basic functionalities.
·
User Evaluation:
The prototype is
presented to users and stakeholders for evaluation and feedback. Users interact
with the prototype to understand how the system might function and to identify
any issues or improvements needed.
·
Refinement:
Based on the
feedback received, the prototype is refined and modified. This process may
involve multiple iterations of prototyping to converge towards a more accurate
representation of the final system.
·
Final System Development:
Once the
prototype is deemed satisfactory and requirements are well-understood, the
final system is developed using the knowledge gained from the prototyping
phase.
·
User Acceptance Testing:
The final system undergoes thorough testing to ensure it meets the specified requirements and is ready for deployment.
Advantages of the Prototyping Model:
- Early user involvement and feedback lead to a better understanding of user needs.
- Rapid identification and correction of potential issues before significant development effort is invested.
- Effective communication between developers and users.
The Spiral Model:
The spiral model, is an evolutionary software
process model that couples the iterative nature of prototyping with the
controlled and systematic aspects of the linear sequential model. It provides
the potential for rapid development of incremental versions of the software.
Using the spiral model, software is developed in a series of incremental
releases. During early iterations, the incremental release might be a paper
model or prototype. During later iterations, increasingly more complete
versions of the engineered system are produced.
The Spiral Model is an iterative
and risk-driven Evolutionary Process Model in software development. It was
proposed by Barry Boehm and combines elements of the Waterfall Model and
iterative development.
The key characteristic of the
Spiral Model is its cyclic approach, with each cycle or spiral representing a
phase in the software development process. The model incorporates risk
assessment and mitigation as an integral part of the development life cycle.
The Spiral Model consists of the following phases:
Planning:
In the planning phase, project
objectives, requirements, and constraints are identified. The project is
divided into smaller increments or iterations, and a plan is developed for each
iteration.
Risk Analysis:
Risk assessment is a crucial
aspect of the Spiral Model. Potential risks and uncertainties related to the
project are identified and analyzed. This phase involves evaluating technical,
schedule, and cost-related risks.
Engineering (Development and
Testing):
In this phase, development and
testing activities are carried out based on the plans developed in the earlier
stages. A prototype or partial system is produced, and the software evolves
with each iteration.
Evaluation:
After each iteration, the project
undergoes a review and evaluation. This includes assessing the progress made,
reviewing the prototype or increment, and obtaining feedback from stakeholders.
The decision is made whether to proceed to the next iteration or continue
refining the current one.
Risk Resolution and Planning
for the Next Iteration:
In this phase, identified risks
are addressed, and plans for the next iteration are formulated. The development
team may adjust the project plan, update risk analyses, and make improvements
based on lessons learned in previous iterations.
Repeat:
The entire process is repeated
for each spiral, with the software evolving and improving through multiple
cycles. Each iteration incorporates feedback, refines the software, and
addresses risks.
Advantages of the Spiral
Model:
- Flexibility to accommodate changes and adjustments throughout the development life cycle.
- Incorporates risk management, leading to early identification and mitigation of potential issues.
- Allows for progressive development and refinement of the software.
Easy to read and understand 😊
ReplyDelete