Unit 1 Software Engineering and Development Models .pptx

The term software engineering is the product of two words, software,
and engineering.
The software is a collection of integrated programs.
Software subsists of carefully-organized instructions and code written by
developers on any of various particular computer languages.
Computer programs and related documentation such as requirements, design
models and user manuals.
Engineering is the application of scientific and practical knowledge to invent,
design, build, maintain, and improve frameworks, processes, etc.

Software Engineering is an engineering branch related to the evolution of
software product using well-defined scientific principles, techniques, and
procedures. The result of software engineering is an effective and reliable
software product.

Why is Software Engineering required?
Software Engineering is required due to the following reasons:
•To manage Large software
•For more Scalability
•Cost Management
•To manage the dynamic nature of software
•For better quality Management

Need of Software Engineering
The necessity of software engineering appears because of a higher rate of progress
in user requirements and the environment on which the program is working.
Huge Programming: It is simpler to manufacture a wall than to a house or
building, similarly, as the measure of programming become extensive engineering
has to step to give it a scientific process.
Adaptability: If the software procedure were not based on scientific and
engineering ideas, it would be simpler to re-create new software than to scale an
existing one.
Cost: As the hardware industry has demonstrated its skills and huge
manufacturing has let down the cost of computer and electronic hardware. But the
cost of programming remains high if the proper process is not adapted.
Dynamic Nature: The continually growing and adapting nature of programming
hugely depends upon the environment in which the client works. If the quality of
the software is continually changing, new upgrades need to be done in the existing
one.
Quality Management: Better procedure of software development provides a
better and quality software product.

Characteristics of a good software engineer
The features that good software engineers should possess are as follows:
Exposure to systematic methods i.e. familiarity with software engineering
principles.
Good technical knowledge of the project range (Domain knowledge).
Good programming abilities.
Good communication skills (These skills comprise of oral, written, and
interpersonal skills).
High motivation.
Sound knowledge of fundamentals of computer science.
Intelligence.
Ability to work in a team

Importance of Software Engineering
The importance of Software engineering is as follows:
Reduces complexity: Big software is always complicated and challenging to
progress. Software engineering has a great solution to reduce the complication
of any project. Software engineering divides big problems into various small
issues. And then start solving each small issue one by one. All these small
problems are solved independently to each other.

To minimize software cost: Software needs a lot of hardwork and software
engineers are highly paid experts. A lot of manpower is required to develop
software with a large number of codes. But in software engineering, programmers
project everything and decrease all those things that are not needed. In turn, the
cost for software productions becomes less as compared to any software that does
not use software engineering method.
To decrease time: Anything that is not made according to the project always
wastes time. And if you are making great software, then you may need to run many
codes to get the definitive running code. This is a very time-consuming procedure,
and if it is not well handled, then this can take a lot of time. So if you are making
your software according to the software engineering method, then it will decrease a
lot of time.
Handling big projects: Big projects are not done in a couple of days, and they
need lots of patience, planning, and management. And to invest six and seven
months of any company, it requires heaps of planning, direction, testing, and
maintenance. No one can say that he has given four months of a company to the
task, and the project is still in its first stage. Because the company has provided
many resources to the plan and it should be completed. So to handle a big project
without any problem, the company has to go for a software engineering method.

Reliable software: Software should be secure, means if you have delivered the
software, then it should work for at least its given time or subscription. And if any
bugs come in the software, the company is responsible for solving all these bugs.
Because in software engineering, testing and maintenance are given, so there is no
worry of its reliability.
Effectiveness: Effectiveness comes if anything has made according to the
standards. Software standards are the big target of companies to make it more
effective. So Software becomes more effective in the act with the help of software
engineering.

Software Processes
The term software specifies to the set of computer programs, procedures and
associated documents (Flowcharts, manuals, etc.) that describe the program
and how they are to be used.
A software process is the set of activities and associated outcome that produce
a software product. Software engineers mostly carry out these activities. These
are four key process activities, which are common to all software processes.
These activities are:
Software specifications: The functionality of the software and constraints on
its operation must be defined.
Software development: The software to meet the requirement must be
produced.
Software validation: The software must be validated to ensure that it does
what the customer wants.
Software evolution: The software must evolve to meet changing client needs.

The Software Process Model
Software Processes is a coherent set of activities for specifying, designing,
implementing and testing software systems.
A software process model is an abstract representation of a process that presents
a description of a process from some particular perspective.
There are many different software processes but all involve:
Specification – defining what the system should do.
Design and implementation – defining the organization of the system and
implementing the system.
Validation – checking that it does what the customer wants.
Evolution – changing the system in response to changing customer needs.

Types of Software Process Model
One of the basic rule of the software development process is SDLC models which
stands for Software Development Life Cycle models.
There are many development life cycle models that have been developed in order
to achieve different required objectives.
The models specify the various stages of the process and the order in which they
are carried out.
The most used, popular and important SDLC models are given below:
Waterfall model
V model
Incremental model
RAD model
Agile model
Iterative model
Spiral model
Prototype model

Waterfall model
Winston Royce introduced the Waterfall Model in 1970.
This model has phases:
Requirement Analysis and Specifications, Design, Development, Testing, Deployment,
Maintenance.
The steps always follow in this order and do not overlap.
The developer must complete every phase before the next phase begins.
This model is named "Waterfall Model", because its diagrammatic representation
resembles a cascade of waterfalls.

Requirements analysis and specification phase: The aim of this phase is to
understand the exact requirements of the customer and to document them
properly. Both the customer and the software developer work together so as to
document all the functions, performance, and interfacing requirement of the
software. It describes the "what" of the system to be produced and not "how."In
this phase, a large document called Software Requirement Specification
(SRS) document is created which contained a detailed description of what the
system will do in the common language.
Design Phase: This phase aims to transform the requirements gathered in the
SRS into a suitable form which permits further coding in a programming
language. It defines the overall software architecture together with high level
and detailed design. All this work is documented as a Software Design
Document (SDD).

Implementation and unit testing: During this phase, design is implemented. If the
SDD is complete, the implementation or coding phase proceeds smoothly, because all
the information needed by software developers is contained in the SDD.
During testing, the code is thoroughly examined and modified. Small modules are
tested in isolation initially. After that these modules are tested by writing some overhead
code to check the interaction between these modules and the flow of intermediate
output.
Integration and System Testing: This phase is highly crucial as the quality
of the end product is determined by the effectiveness of the testing carried out.
The better output will lead to satisfied customers, lower maintenance costs, and
accurate results. Unit testing determines the efficiency of individual modules.
However, in this phase, the modules are tested for their interactions with each
other and with the system.
Operation and maintenance phase: Maintenance is the task performed by
every user once the software has been delivered to the customer, installed, and
operational.

When to use SDLC Waterfall Model?
Some Circumstances where the use of the Waterfall model is most suited are:
1. When the requirements are constant and not changed regularly.
2. A project is short
3. The situation is calm
4. Where the tools and technology used is consistent and is not changing
5. When resources are well prepared and are available to use.

Advantages of Waterfall model
I. This model is simple to implement also the number of resources that are required for
it is minimal.
II. The requirements are simple and explicitly declared; they remain unchanged during
the entire project development.
III. The start and end points for each phase is fixed, which makes it easy to cover
progress.
IV. The release date for the complete product, as well as its final cost, can be
determined before development.
V. It gives easy to control and clarity for the customer due to a strict reporting system.
Disadvantages of Waterfall model
I. In this model, the risk factor is higher, so this model is not suitable for more
significant and complex projects.
II. This model cannot accept the changes in requirements during development.
III. It becomes tough to go back to the phase. For example, if the application has now
shifted to the coding phase, and there is a change in requirement, It becomes tough to
go back and change it.
IV. Since the testing done at a later stage, it does not allow identifying the challenges
and risks in the earlier phase, so the risk reduction strategy is difficult to prepare.

RAD (Rapid Application Development) Model

RAD is a linear sequential software development process model that emphasizes a
concise development cycle using an element based construction approach.
If the requirements are well understood and described, and the project scope is a
constraint, the RAD process enables a development team to create a fully functional
system within a concise time period.
RAD (Rapid Application Development) is a concept that products can be developed
faster and of higher quality through:
Gathering requirements using workshops or focus groups
Prototyping and early, reiterative user testing of designs
The re-use of software components
A rigidly paced schedule that refers design improvements to the next product version
Less formality in reviews and other team communication

Unit 1 Software Engineering and Development Models .pptx

The various phases of RAD are as follows:
1.Business Modelling: The information flow among business functions is
defined by answering questions like what data drives the business process,
what data is generated, who generates it, where does the information go, who
process it and so on.
2. Data Modelling: The data collected from business modeling is refined
into a set of data objects (entities) that are needed to support the business.
The attributes (character of each entity) are identified, and the relation
between these data objects (entities) is defined.
3. Process Modelling: The information object defined in the data modeling
phase are transformed to achieve the data flow necessary to implement a
business function. Processing descriptions are created for adding, modifying,
deleting, or retrieving a data object.

4. Application Generation: Automated tools are used to facilitate construction of the
software; even they use the 4th GL techniques.
5. Testing & Turnover: Many of the programming components have already been
tested since RAD emphasis reuse. This reduces the overall testing time. But the new part
must be tested, and all interfaces must be fully exercised.
When to use RAD Model?
When the system should need to create the project that modularizes in a
short span time (2-3 months).
When the requirements are well-known.
When the technical risk is limited.
When there's a necessity to make a system, which modularized in 2-3
months of period.
It should be used only if the budget allows the use of automatic code
generating tools.

Advantage of RAD Model
This model is flexible for change.
In this model, changes are adoptable.
Each phase in RAD brings highest priority functionality to the customer.
It reduced development time.
It increases the reusability of features.
Disadvantage of RAD Model
It required highly skilled designers.
All application is not compatible with RAD.
For smaller projects, we cannot use the RAD model.
On the high technical risk, it's not suitable.
Required user involvement.

The spiral model, initially proposed by Boehm, is an evolutionary software
process model that couples the iterative feature of prototyping with the
controlled and systematic aspects of the linear sequential model.
It implements the potential for rapid development of new versions of the
software. Using the spiral model, the software is developed in a series of
incremental releases. During the early iterations, the additional release may be a
paper model or prototype.
During later iterations, more and more complete versions of the engineered
system are produced.

Each cycle in the spiral is divided into four parts:
Objective setting: Each cycle in the spiral starts with the identification of
purpose for that cycle, the various alternatives that are possible for achieving
the targets, and the constraints that exists.
Risk Assessment and reduction: The next phase in the cycle is to calculate
these various alternatives based on the goals and constraints. The focus of
evaluation in this stage is located on the risk perception for the project.
Development and validation: The next phase is to develop strategies that
resolve uncertainties and risks. This process may include activities such as
benchmarking, simulation, and prototyping.
Planning: Finally, the next step is planned. The project is reviewed, and a
choice made whether to continue with a further period of the spiral. If it is
determined to keep, plans are drawn up for the next step of the project.
The risk-driven feature of the spiral model allows it to accommodate any
mixture of a specification-oriented, prototype-oriented, simulation-oriented,
or another type of approach. An essential element of the model is that each
period of the spiral is completed by a review that includes all the products
developed during that cycle, including plans for the next cycle. The spiral
model works for development as well as enhancement projects.

When to use Spiral Model?
When deliverance is required to be frequent.
When the project is large
When requirements are unclear and complex
When changes may require at any time
Large and high budget projects
Advantages
High amount of risk analysis
Useful for large and mission-critical projects.
Disadvantages
Can be a costly model to use.
Risk analysis needed highly particular expertise
Doesn't work well for smaller projects.

V-Model also referred to as the Verification and Validation Model.
In this, each phase of SDLC must complete before the next phase starts.
It follows a sequential design process same as the waterfall model.
Testing of the device is planned in parallel with a corresponding stage of
development.
Verification: It involves a static analysis method (review) done without
executing code. It is the process of evaluation of the product development
process to find whether specified requirements meet.
Validation: It involves dynamic analysis method (functional, non-functional),
testing is done by executing code. Validation is the process to classify the
software after the completion of the development process to determine whether
the software meets the customer expectations and requirements.
So V-Model contains Verification phases on one side of the Validation phases on
the other side. Verification and Validation process is joined by coding phase in V-
shape. Thus it is known as V-Model.

There are the various phases of Verification Phase of V-model:
1. Business requirement analysis: This is the first step where product
requirements understood from the customer's side. This phase contains
detailed communication to understand customer's expectations and exact
requirements.
2. System Design: In this stage system engineers analyze and interpret the
business of the proposed system by studying the user requirements
document.
3. Architecture Design: The baseline in selecting the architecture is that it
should understand all which typically consists of the list of modules, brief
functionality of each module, their interface relationships, dependencies,
database tables, architecture diagrams, technology detail, etc. The
integration testing model is carried out in a particular phase.

4. Module Design: In the module design phase, the system breaks down
into small modules. The detailed design of the modules is specified,
which is known as Low-Level Design.
5. Coding Phase: After designing, the coding phase is started. Based on the
requirements, a suitable programming language is decided. There are
some guidelines and standards for coding. Before checking in the
repository, the final build is optimized for better performance, and the
code goes through many code reviews to check the performance.

There are the various phases of Validation Phase of V-model:
1. Unit Testing: In the V-Model, Unit Test Plans (UTPs) are developed
during the module design phase. These UTPs are executed to eliminate
errors at code level or unit level. A unit is the smallest entity which can
independently exist, e.g., a program module. Unit testing verifies that the
smallest entity can function correctly when isolated from the rest of the
codes/ units.
2. Integration Testing: Integration Test Plans are developed during the
Architectural Design Phase. These tests verify that groups created and
tested independently can coexist and communicate among themselves.

3. System Testing: System Tests Plans are developed during System
Design Phase. Unlike Unit and Integration Test Plans, System Tests
Plans are composed by the client?s business team. System Test ensures
that expectations from an application developer are met.
4. Acceptance Testing: Acceptance testing is related to the business
requirement analysis part. It includes testing the software product in user
atmosphere. Acceptance tests reveal the compatibility problems with the
different systems, which is available within the user atmosphere. It
conjointly discovers the non-functional problems like load and
performance defects within the real user atmosphere.
When to use V-Model?
1. When the requirement is well defined and not ambiguous.
2. The V-shaped model should be used for small to medium-sized projects
where requirements are clearly defined and fixed.
3. The V-shaped model should be chosen when sample technical resources are
available with essential technical expertise.

Advantage (Pros) of V-Model:
1. Easy to Understand.
2. Testing Methods like planning, test designing happens well before coding.
3. This saves a lot of time. Hence a higher chance of success over the waterfall
model.
4. Avoids the downward flow of the defects.
5. Works well for small plans where requirements are easily understood.
Disadvantage (Cons) of V-Model:
6. Very rigid and least flexible.
7. Not a good for a complex project.
8. Software is developed during the implementation stage, so no early
prototypes of the software are produced.
9. If any changes happen in the midway, then the test documents along with
the required documents, has to be updated.

Incremental Model is a process of software development where requirements
divided into multiple standalone modules of the software development cycle. In
this model, each module goes through the requirements, design, implementation
and testing phases. Every subsequent release of the module adds function to the
previous release. The process continues until the complete system achieved.

The various phases of incremental model are as follows:
1. Requirement analysis: In the first phase of the incremental model, the
product analysis expertise identifies the requirements. And the system functional
requirements are understood by the requirement analysis team. To develop the
software under the incremental model, this phase performs a crucial role.
2. Design & Development: In this phase of the Incremental model of SDLC, the
design of the system functionality and the development method are finished with
success. When software develops new practicality, the incremental model uses
style and development phase.
3. Testing: In the incremental model, the testing phase checks the performance
of each existing function as well as additional functionality. In the testing phase,
the various methods are used to test the behaviour of each task.
4. Implementation: Implementation phase enables the coding phase of the
development system. It involves the final coding that design in the designing and
development phase and tests the functionality in the testing phase. After
completion of this phase, the number of the product working is enhanced and
upgraded up to the final system product

When we use the Incremental Model?
•When the requirements are superior.
•A project has a lengthy development schedule.
•When Software team are not very well skilled or trained.
•When the customer demands a quick release of the product.
•You can develop prioritized requirements first.
Advantage of Incremental Model
Errors are easy to be recognized.
Easier to test and debug
More flexible.
Simple to manage risk because it handled during its iteration.
The Client gets important functionality early.
Disadvantage of Incremental Model
Need for good planning
Total Cost is high.
Well defined module interfaces are needed.

Agile SDLC model is a combination of iterative and incremental process models
with focus on process adaptability and customer satisfaction by rapid delivery of
working software product.
Agile Methods break the product into small incremental builds. These builds are
provided in iterations. Each iteration typically lasts from about one to three
weeks.
Every iteration involves cross functional teams working simultaneously on
various areas like −
Planning
Requirements Analysis
Design
Coding
Unit Testing and
Acceptance Testing.
At the end of the iteration, a working product is displayed to the customer and
important stakeholders.

Agile model believes that every project needs to be handled differently and the
existing methods need to be tailored to best suit the project requirements. In
Agile, the tasks are divided to time boxes (small time frames) to deliver
specific features for a release.
Iterative approach is taken and working software build is delivered after each
iteration. Each build is incremental in terms of features; the final build holds
all the features required by the customer.
Here is a graphical illustration of the Agile Model −

The Agile thought process had started early in the software development and
started becoming popular with time due to its flexibility and adaptability.
The most popular Agile methods include Rational Unified Process (1994),
Scrum (1995), Crystal Clear, Extreme Programming (1996), Adaptive Software
Development, Feature Driven Development, and Dynamic Systems
Development Method (DSDM) (1995).
These are now collectively referred to as Agile Methodologies, after the Agile
Manifesto was published in 2001.
Following are the Agile Manifesto principles −
Individuals and interactions − In Agile development, self-organization and
motivation are important, as are interactions like co-location and pair
programming.
Working software − Demo working software is considered the best means of
communication with the customers to understand their requirements, instead of
just depending on documentation.

Customer collaboration − As the requirements cannot be gathered
completely in the beginning of the project due to various factors, continuous
customer interaction is very important to get proper product requirements.
Responding to change − Agile Development is focused on quick responses
to change and continuous development.

Agile is based on the adaptive software development methods, whereas the
traditional SDLC models like the waterfall model is based on a predictive
approach.
Predictive teams in the traditional SDLC models usually work with detailed
planning and have a complete forecast of the exact tasks and features to be
delivered in the next few months or during the product life cycle.
Predictive methods entirely depend on the requirement analysis and
planning done in the beginning of cycle.
Any changes to be incorporated go through a strict change control
management and prioritization.
Agile Vs Traditional SDLC Models

Agile uses an adaptive approach where there is no detailed planning and
there is clarity on future tasks only in respect of what features need to be
developed. There is feature driven development and the team adapts to the
changing product requirements dynamically.
The product is tested very frequently, through the release iterations,
minimizing the risk of any major failures in future.
Customer Interaction is the backbone of this Agile methodology, and open
communication with minimum documentation are the typical features of Agile
development environment.
The agile teams work in close collaboration with each other and are most often
located in the same geographical location.

The advantages of the Agile Model
Is a very realistic approach to software development.
Promotes teamwork and cross training.
Functionality can be developed rapidly and demonstrated.
Resource requirements are minimum.
Suitable for fixed or changing requirements
Delivers early partial working solutions.
Good model for environments that change steadily.
Minimal rules, documentation easily employed.
Enables concurrent development and delivery within an overall planned
context.
Little or no planning required.
Easy to manage.
Gives flexibility to developers.

The disadvantages of the Agile Model
Not suitable for handling complex dependencies.
More risk of sustainability, maintainability and extensibility.
An overall plan, an agile leader and agile PM practice is a must without which
it will not work.
Strict delivery management dictates the scope, functionality to be delivered,
and adjustments to meet the deadlines.
Depends heavily on customer interaction, so if customer is not clear, team can
be driven in the wrong direction.
There is a very high individual dependency, since there is minimum
documentation generated.
Transfer of technology to new team members may be quite challenging due to
lack of documentation.

In this Model, you can start with some of the software specifications and
develop the first version of the software. After the first version if there is a need
to change the software, then a new version of the software is created with a new
iteration.
Every release of the Iterative Model finishes in an exact and fixed period that is
called iteration.
The Iterative Model allows the accessing earlier phases, in which the variations
made respectively. The final output of the project renewed at the end of the
Software Development Life Cycle (SDLC) process.

The various phases of Iterative model are :
1. Requirement gathering & analysis: In this phase, requirements are gathered
from customers and check by an analyst whether requirements will fulfil or not.
Analyst checks that need will achieve within budget or not. After all of this, the
software team skips to the next phase.
2. Design: In the design phase, team design the software by the different
diagrams like Data Flow diagram, activity diagram, class diagram, state
transition diagram, etc.
3. Implementation: In the implementation, requirements are written in the
coding language and transformed into computer programmes which are called
Software.
4. Testing: After completing the coding phase, software testing starts using
different test methods. There are many test methods, but the most common are
white box, black box, and grey box test methods.

5. Deployment: After completing all the phases, software is deployed to its
work environment.
6. Review: In this phase, after the product deployment, review phase is
performed to check the behaviour and validity of the developed product. And if
there are any error found then the process starts again from the requirement
gathering.
7. Maintenance: In the maintenance phase, after deployment of the software
in the working environment there may be some bugs, some errors or new
updates are required. Maintenance involves debugging and new addition
options.
When to use the Iterative Model?
When requirements are defined clearly and easy to understand.
When the software application is large.
When there is a requirement of changes in future.

Advantage(Pros) of Iterative Model:
Testing and debugging during smaller iteration is easy.
A Parallel development can plan.
It is easily acceptable to ever-changing needs of the project.
Risks are identified and resolved during iteration.
Limited time spent on documentation and extra time on designing.
Disadvantage(Cons) of Iterative Model:
It is not suitable for smaller projects.
More Resources may be required.
Design can be changed again and again because of imperfect requirements.
Requirement changes can cause over budget.
Project completion date not confirmed because of changing requirements.

The Big Bang model is an SDLC model where we do not follow any specific
process. The development just starts with the required money and efforts as the
input, and the output is the software developed which may or may not be as per
customer requirement.
This Big Bang Model does not follow a process/procedure and there is a very
little planning required.
Even the customer is not sure about what exactly he wants and the requirements
are implemented on the fly without much analysis.
Usually this model is followed for small projects where the development teams
are very small.

Big Bang Model ─ Design and Application
The Big Bang Model comprises of focusing all the possible resources in the
software development and coding, with very little or no planning.
The requirements are understood and implemented as they come. Any changes
required may or may not need to revamp the complete software.
This model is ideal for small projects with one or two developers working
together and is also useful for academic or practice projects.
It is an ideal model for the product where requirements are not well understood
and the final release date is not given.

The advantages of the Big Bang Model are as follows −
1. This is a very simple model
2. Little or no planning required
3. Easy to manage
4. Very few resources required
5. Gives flexibility to developers
6. It is a good learning aid for new comers or students.
The disadvantages of the Big Bang Model are as follows −
7. Very High risk and uncertainty.
8. Not a good model for complex and object-oriented projects.
9. Poor model for long and ongoing projects.
10. Can turn out to be very expensive if requirements are misunderstood.

The Prototyping Model is one of the most popularly used Software
Development Life Cycle Models (SDLC models).
This model is used when the customers do not know the exact project
requirements beforehand. In this model, a prototype of the end product is
first developed, tested, and refined as per customer feedback repeatedly till
a final acceptable prototype is achieved which forms the basis for
developing the final product.
Steps of Prototype Model :-
Requirement Gathering and Analyst
Quick Decision
Build a Prototype
Assessment or User Evaluation
Prototype Refinement
Engineer Product

Advantage of Prototype Model
I. Reduce the risk of incorrect user requirement
II. Good where requirement are changing/uncommitted
III. Regular visible process aids management
IV. Support early product marketing
V. Reduce Maintenance cost.
VI. Errors can be detected much earlier as the system is made side by side.
Disadvantage of Prototype Model
1. An unstable/badly implemented prototype often becomes the final product.
2. Require extensive customer collaboration
I. Costs customer money
II. Needs committed customer
III. Difficult to finish if customer withdraw
IV. May be too customer specific, no broad market
3. Difficult to know how long the project will last.
4. Easy to fall back into the code and fix without proper requirement analysis, design,
customer evaluation, and feedback.
5. Prototyping tools are expensive.
6. Special tools & techniques are required to build a prototype.
7. It is a time-consuming process.

RUP
“Rational Unified Process”

• RATIONAL UNIFIED PROCESS (RUP):
Rational Unified Process (RUP) is an object-oriented and Web-enabled program development
methodology. RUP is a software application development technique with many tools to assist
in coding the final product and tasks related to this goal. RUP is an object-oriented approach
used to ensure effective project management and high-quality software production. It divides
the development process into four distinct phases that each involves business modeling,
analysis and design, implementation, testing, and deployment. The four phases are:
1. Inception - The idea for the project is stated. The development team determines if the project is
worth pursuing and what resources will be needed.
2. Elaboration - The project's architecture and required resources are further evaluated.
Developers consider possible applications of the software and costs associated with the
development.
3. Construction - The project is developed and completed. The software is designed, written, and
tested.
4. Transition - The software is released to the public. Final adjustments or updates are made based
on feedback from end users.
The RUP development methodology provides a structured way for companies to envision create
software programs. Since it provides a specific plan for each step of the development process,
it helps prevent resources from being wasted and reduces unexpected development costs.

Advantages of RUP Software Development: -
•This is a complete methodology in itself with an emphasis on accurate documentation
•· It is pro-actively able to resolve the project risks associated with the client's evolving
requirements
•requiring careful change request management
•· Less time is required for integration as the process of integration goes on throughout the
software
•development life cycle.
•· The development time required is less due to reuse of components.
•· There is online training and tutorial available for this process.
Disadvantages of RUP Software Development: -
• The team members need to be expert in their field to develop a software under this
methodology.
• The development process is too complex and disorganized.
• On cutting edge projects which utilize new technology, the reuse of components will not
be possible. Hence the time saving one could have made will be impossible to fulfill.
• Integration throughout the process of software development, in theory sounds a good
thing. But on particularly big projects with multiple development streams it will only add
to the confusion and cause more issues during the stages of testing.

The Capability Maturity Model (CMM) is a procedure used to develop and refine an
organization's software development process.
The model defines a five-level evolutionary stage of increasingly organized and
consistently more mature processes.
CMM was developed and is promoted by the Software Engineering Institute (SEI), a
research and development center promote by the U.S. Department of Defense (DOD).
Capability Maturity Model is used as a benchmark to measure the maturity of an
organization's software process.
Capability Maturity Model (CMM)

Methods of CMM
There are two methods of SEICMM:
Capability Evaluation: Capability evaluation provides a way to assess the software
process capability of an organization.
The results of capability evaluation indicate the likely contractor performance
if the contractor is awarded a work.
Therefore, the results of the software process capability assessment
can be used to select a contractor.
Software Process Assessment: Software process assessment is used by an
organization to improve its process capability. Thus, this type of evaluation is for
purely internal use.

SEI CMM categorized software development industries into the following five maturity
levels.
The various levels of SEI CMM have been designed so that it is easy for an organization to
build its quality system starting from scratch slowly.
Level 1: Initial
Ad hoc activities characterize a software development organization at this level. Very few
or no processes are described and followed. Since software production processes are not
limited, different engineers follow their process and as a result, development efforts
become chaotic. Therefore, it is also called a chaotic level.
Level 2: Repeatable
At this level, the fundamental project management practices like tracking cost and
schedule are established. Size and cost estimation methods, like function point analysis,
COCOMO, etc. are used.

Level 3: Defined
At this level, the methods for both management and development activities are
defined and documented. There is a common organization-wide understanding of
operations, roles, and responsibilities. The ways through defined, the process and
product qualities are not measured. ISO 9000 goals at achieving this level.
Level 4: Managed
At this level, the focus is on software metrics. Two kinds of metrics are composed.
Product metrics measure the features of the product being developed, such as its size,
reliability, time complexity, understandability, etc.
Process metrics follow the effectiveness of the process being used, such as average
defect correction time, productivity, the average number of defects found per hour
inspection, the average number of failures detected during testing per LOC, etc. The
software process and product quality are measured, and quantitative quality
requirements for the product are met. Various tools like Pareto charts, fishbone
diagrams, etc. are used to measure the product and process quality. The process
metrics are used to analyze if a project performed satisfactorily. Thus, the outcome of
process measurements is used to calculate project performance rather than improve
the process.

Level 5: Optimizing
At this phase, process and product metrics are collected. Process and product
measurement data are evaluated for continuous process improvement.

Unit 1 Software Engineering and Development Models .pptx

More Related Content

Similar to Unit 1 Software Engineering and Development Models .pptx (20)

Recently uploaded (20)

Unit 1 Software Engineering and Development Models .pptx