BCSE301L SOFTWARE

ENGINEERING
Dr.D.KAVITHA
SCOPE
VIT, CHENNAI
 Module:1 OVERVIEW OF SOFTWARE ENGINEERING
• Nature of Software, Software Engineering, Software process, project,
product, Process Models ,Classical Evolutionary models, Introduction
to Agility - Agile Process-Extreme programming - XP Process –
Principles of Agile Software Development framework - Overview of
System Engineering
Nature of Software &Software Engineering
• 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.
 Requirement of software engineering
• To manage Large software
• For more Scalability
• Cost Management
• To manage the dynamic nature of software
• For better quality Management
 Need of Software Engineering
• 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.
 Characteristics of a good software engineer
• 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
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:
1. Software specifications: The functionality of the software and
constraints on its operation must be defined.
2. Software development: The software to meet the requirement must
be produced.
3. Software validation: The software must be validated to ensure that
it does what the customer wants.
4. Software evolution: The software must evolve to meet changing
client needs.
 Software Process Model
A software process model is a specified definition of a software
process, which is presented from a particular perspective.
Models, by their nature, are a simplification, so a software
process model is an abstraction of the actual process, which is
being described. Process models may contain activities, which
are part of the software process, software product, and the roles
of people involved in software engineering. Some examples of
the types of software process models that may be produced are:
1. A workflow model: This shows the series of activities in the
process along with their inputs, outputs and dependencies. The
activities in this model perform human actions.
2. A dataflow or activity model: This represents the process as
a set of activities, each of which carries out some data
transformations. It shows how the input to the process, such as a
specification is converted to an output such as a design. The
activities here may be at a lower level than activities in a
workflow model. They may perform transformations carried out
by people or by computers.

3.A role/action model: This means the roles of the people

involved in the software process and the activities for which they
are responsible.
 General models of software development
1. The waterfall approach: This takes the above activities and
produces them as separate process phases such as requirements
specification, software design, implementation, testing, and so on.
After each stage is defined, it is "signed off" and development goes
onto the following stage.
2. Evolutionary development: This method interleaves the activities
of specification, development, and validation. An initial system is
rapidly developed from a very abstract specification.
3. Formal transformation: This method is based on producing a
formal mathematical system specification and transforming this
specification, using mathematical methods to a program. These
transformations are 'correctness preserving.' This means that you
can be sure that the developed programs meet its specification.
4. System assembly from reusable components: This method
assumes the parts of the system already exist. The system
development process target on integrating these parts rather than
developing them from scratch.
 Software Crisis
1. Size: Software is becoming more expensive and more complex with
the growing complexity and expectation out of software. For
example, the code in the consumer product is doubling every couple
of years.
2. Quality: Many software products have poor quality, i.e., the software
products defects after putting into use due to ineffective testing
technique. For example, Software testing typically finds 25 errors per
1000 lines of code.
3. Cost: Software development is costly i.e. in terms of time taken to
develop and the money involved. For example, Development of the
AA's Advanced Automation System cost over $700 per lines of code.
4. Delayed Delivery: Serious schedule overruns are common. Very
often the software takes longer than the estimated time to develop,
which in turn leads to cost shooting up. For example, one in four
large-scale development projects is never completed.
 Program vs. Software
• Software is more than programs. Any program is a subset of
software, and it becomes software only if documentation &
operating procedures manuals are prepared.
• There are three components of the software as shown in fig:
1. Program: Program is a combination of source code & object
code.
2. Documentation: Documentation consists of different types of
manuals. Examples of documentation manuals are: Data Flow
Diagram, Flow Charts, ER diagrams, etc.
3. Operating Procedures: Operating Procedures consist of
instructions to set up and use the software system and
instructions on how react to the system failure. Example of
operating system procedures manuals is: installation guide,
Beginner's guide, reference guide, system administration guide,
etc.
Software Development Life Cycle (SDLC)
• A software life cycle model (also termed process model) is a
pictorial and diagrammatic representation of the software life
cycle. A life cycle model represents all the methods required to
make a software product transit through its life cycle stages. It
also captures the structure in which these methods are to be
undertaken.
Need of SDLC
• The development team must determine a suitable life cycle
model for a particular plan and then observe to it.
• Without using an exact life cycle model, the development of a
software product would not be in a systematic and disciplined
manner. When a team is developing a software product, there
must be a clear understanding among team representative
about when and what to do. Otherwise, it would point to chaos
and project failure.
 SDLC Cycle
• SDLC Cycle represents the process of developing software.
SDLC framework includes the following steps:
The stages of SDLC are as follows:
Stage1: Planning and requirement analysis
• Requirement Analysis is the most important and necessary stage in SDLC.
• The senior members of the team perform it with inputs from all the stakeholders and
domain experts or SMEs in the industry.
• Planning for the quality assurance requirements and identifications of the risks associated
with the projects is also done at this stage.
• Business analyst and Project organizer set up a meeting with the client to gather all the
data like what the customer wants to build, who will be the end user, what is the
objective of the product. Before creating a product, a core understanding or knowledge
of the product is very necessary.
• For Example, A client wants to have an application which concerns money
transactions. In this method, the requirement has to be precise like what kind of
operations will be done, how it will be done, in which currency it will be done, etc.
• Once the requirement is understood, the SRS (Software Requirement
Specification) document is created. The developers should thoroughly follow this
document and also should be reviewed by the customer for future reference.
 Stage2: Defining Requirements
• Once the requirement analysis is done, the next stage is to
certainly represent and document the software requirements
and get them accepted from the project stakeholders.
• This is accomplished through "SRS"- Software Requirement
Specification document which contains all the product
requirements to be constructed and developed during the
project life cycle.
Stage3: Designing the Software
• The next phase is about to bring down all the knowledge of
requirements, analysis, and design of the software project. This
phase is the product of the last two, like inputs from the
customer and requirement gathering.
 Stage4: Developing the project
• In this phase of SDLC, the actual development begins, and the
programming is built. The implementation of design begins
concerning writing code. Developers have to follow the coding
guidelines described by their management and programming
tools like compilers, interpreters, debuggers, etc. are used to
develop and implement the code.
Stage5: Testing
• After the code is generated, it is tested against the
requirements to make sure that the products are solving the
needs addressed and gathered during the requirements stage.
• During this stage, unit testing, integration testing, system
testing, acceptance testing are done.
 Stage6: Deployment
• Once the software is certified, and no bugs or errors are stated,
then it is deployed.
• Then based on the assessment, the software may be released
as it is or with suggested enhancement in the object segment.
• After the software is deployed, then its maintenance begins.
Stage7: Maintenance
• Once when the client starts using the developed systems, then
the real issues come up and requirements to be solved from
time to time.
• This procedure where the care is taken for the developed
product is known as maintenance.
 Waterfall model
• Winston Royce introduced the Waterfall Model in 1970.This model
has five phases: Requirements analysis and specification, design,
implementation, and unit testing, integration and system testing, and
operation and 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.
1. 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.
2. 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).
3. 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.
• 4. 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.
• 5. 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:

• When the requirements are constant and not changed regularly.

• A project is short
• Where the tools and technology used is consistent and is not
changing
• When resources are well prepared and are available to use.
 Advantages of Waterfall model
• This model is simple to implement also the number of
resources that are required for it is minimal.
• The requirements are simple and explicitly declared; they
remain unchanged during the entire project development.
• The start and end points for each phase is fixed, which makes
it easy to cover progress.
• The release date for the complete product, as well as its final
cost, can be determined before development.
• It gives easy to control and clarity for the customer due to a
strict reporting system.
 Disadvantages of Waterfall model
• In this model, the risk factor is higher, so this model is not
suitable for more significant and complex projects.
• This model cannot accept the changes in requirements during
development.
• 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.
• 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
 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;
• 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.
 Spiral Model
• 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.
 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
• 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.
 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 clients 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?
• When the requirement is well defined and not ambiguous.
• The V-shaped model should be used for small to medium-sized
projects where requirements are clearly defined and fixed.
• 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:
1. Very rigid and least flexible.
2. Not a good for a complex project.
3. Software is developed during the implementation stage, so no
early prototypes of the software are produced.
4. If any changes happen in the midway, then the test documents
along with the required documents, has to be updated.
 Incremental Model
• 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 behavior 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 Model
• The meaning of Agile is swift or versatile.
• "Agile process model" refers to a software development approach
based on iterative development. Agile methods break tasks into
smaller iterations, or parts do not directly involve long term planning.
The project scope and requirements are laid down at the beginning
of the development process. Plans regarding the number of
iterations, the duration and the scope of each iteration are clearly
defined in advance.
• Each iteration is considered as a short time "frame" in the Agile
process model, which typically lasts from one to four weeks. The
division of the entire project into smaller parts helps to minimize the
project risk and to reduce the overall project delivery time
requirements. Each iteration involves a team working through a full
software development life cycle including planning, requirements
analysis, design, coding, and testing before a working product is
demonstrated to the client.
 Phases of Agile Model:
Following are the phases in the Agile model are as follows:
1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback
1. Requirements gathering: In this phase, you must define the
requirements. You should explain business opportunities and plan the
time and effort needed to build the project. Based on this information,
you can evaluate technical and economic feasibility.
2. Design the requirements: When you have identified the project, work
with stakeholders to define requirements. You can use the user flow diagram
or the high-level UML diagram to show the work of new features and show
how it will apply to your existing system.
3. Construction/ iteration: When the team defines the requirements, the
work begins. Designers and developers start working on their project, which
aims to deploy a working product. The product will undergo various stages
of improvement, so it includes simple, minimal functionality.
4. Testing: In this phase, the Quality Assurance team examines the
product's performance and looks for the bug.
5. Deployment: In this phase, the team issues a product for the user's work
environment.
6. Feedback: After releasing the product, the last step is feedback. In this,
the team receives feedback about the product and works through the
feedback.
 Agile Testing Methods:
• Scrum
• Crystal
• Dynamic Software Development Method(DSDM)
• Feature Driven Development(FDD)
• Lean Software Development
• eXtreme Programming(XP)
 SCRUM
• SCRUM is an agile development process focused primarily on
ways to manage tasks in team-based development conditions.
• There are three roles in it, and their responsibilities are:
• Scrum Master: The scrum can set up the master team,
arrange the meeting and remove obstacles for the process
• Product owner: The product owner makes the product
backlog, prioritizes the delay and is responsible for the
distribution of functionality on each repetition.
• Scrum Team: The team manages its work and organizes the
work to complete the sprint or cycle.
 eXtreme Programming(XP)
• This type of methodology is used when customers are
constantly changing demands or requirements, or when they
are not sure about the system's performance.
• Extreme Programming or simply called as XP prioritizes
customer satisfaction over anything else. Developed by Kent
Beck, XP requires higher level of involvement from both Client
as well as developers.
• where there is frequent changes in customer requirement can
opt for XP as it is flexible regarding changes at any time of the
production.
It focuses on short deliveries with checkpoints all over the project in order to analyze if there is any
changes in requirement and act accordingly.
• XP is largely dependent on its developer team’s ability to coordinate.
• There are 5 phases in Extreme programming, which are
Planning −
• The initial phase where clients and the developers meet and discuss
about the requirement and scope of the development.
• Based on the client input, developer team prepare short iterative
user stories or development cycles for the full development as a
whole. Based on the stories created, duration and cost of the project
is defined.
Designing
• user stories are broken down into smaller tasks and further analysis
is done regarding the execution.
• Even development standards such as class and method names,
architecture and formats etc. are planned during designing. Test
cases are concurrently prepared for those iterative tasks.
 Coding −
• The most important phase where the development based on the
planning takes place which include coding based on requirement
and simultaneous documentation for updating customer regarding
the present status.
Testing −
• Once the coding is done, user acceptance testing is started. XP
integrates testing during the coding phase itself for testing and
development to run simultaneously. Based on the test results, bugs
are eliminated and then the product goes through customer
acceptance testing which is based on the customer requirements.
Closure −
• Here, once the product is delivered, the team awaits for customer as
well as manager feedback. Based on the feedback, they again follow
the same planning-coding-testing iteration till customer acceptance
test is passed.
 Crystal:
• There are three concepts of this method-
1. Chartering: Multi activities are involved in this phase such as
making a development team, performing feasibility analysis,
developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:
1. Team updates the release plan.
2. Integrated product delivers to the users.
3. Wrap up: According to the user environment, this phase
performs deployment, post-deployment.
• Dynamic Software Development Method(DSDM):
DSDM is a rapid application development strategy for software development and gives an
agile project distribution structure. The essential features of DSDM are that users must be
actively connected, and teams have been given the right to make decisions. The techniques
used in DSDM are:
1. Time Boxing
2. MoSCoW Rules
3. Prototyping
The DSDM project contains seven stages:
1. Pre-project
2. Feasibility Study
3. Business Study
4. Functional Model Iteration
5. Design and build Iteration
6. Implementation
7. Post-project
 Feature Driven Development(FDD):
• This method focuses on "Designing and Building" features. In
contrast to other smart methods, FDD describes the small
steps of the work that should be obtained separately per
function.
Lean Software Development:
• Lean software development methodology follows the principle
"just in time production." The lean method indicates the
increasing speed of software development and reducing costs.
 When to use the Agile Model?
• When frequent changes are required.
• When a highly qualified and experienced team is available.
• When a customer is ready to have a meeting with a software
team all the time.
• When project size is small.
 Advantage(Pros) of Agile Method:
1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.
Disadvantages(Cons) of Agile Model:
1. Due to the shortage of formal documents, it creates confusion and
crucial decisions taken throughout various phases can be
misinterpreted at any time by different team members.
2. Due to the lack of proper documentation, once the project completes
and the developers allotted to another project, maintenance of the
finished project can become a difficulty.
 Iterative Model
• 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 as follows:
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
programs 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 behavior 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?
1. When requirements are defined clearly and easy to understand.
2. When the software application is large.
3. When there is a requirement of changes in future.
 • Advantage(Pros) of Iterative Model:
1. Testing and debugging during smaller iteration is easy.
2. A Parallel development can plan.
3. It is easily acceptable to ever-changing needs of the project.
4. Risks are identified and resolved during iteration.
5. Limited time spent on documentation and extra time on designing.
• Disadvantage(Cons) of Iterative Model:
1. It is not suitable for smaller projects.
2. More Resources may be required.
3. Design can be changed again and again because of imperfect
requirements.
4. Requirement changes can cause over budget.
5. Project completion date not confirmed because of changing
requirements.
 Big Bang Model
• In this model, developers do not follow any specific process.
Development begins with the necessary funds and efforts in the
form of inputs. And the result may or may not be as per the
customer's requirement, because in this model, even the
customer requirements are not defined.
• This model is ideal for small projects like academic projects or
practical projects. One or two developers can work together on
this model.
 • When to use Big Bang Model?
• As we discussed above, this model is required when this
project is small like an academic project or a practical project.
This method is also used when the size of the developer team
is small and when requirements are not defined, and the
release date is not confirmed or given by the customer.
• Advantage(Pros) of Big Bang Model:
1. There is no planning required.
2. Simple Model.
3. Few resources required.
4. Easy to manage.
5. Flexible for developers.
 Disadvantage(Cons) of Big Bang Model:
1. There are high risk and uncertainty.
2. Not acceptable for a large project.
3. If requirements are not clear that can cause very expensive.
 Prototype Model
• The prototype model requires that before carrying out the
development of actual software, a working prototype of the
system should be built. A prototype is a toy implementation of
the system. A prototype usually turns out to be a very crude
version of the actual system, possible exhibiting limited
functional capabilities, low reliability, and inefficient
performance as compared to actual software.
• In many instances, the client only has a general view of what
is expected from the software product. In such a scenario
where there is an absence of detailed information regarding the
input to the system, the processing needs, and the output
requirement, the prototyping model may be employed.
 Steps of Prototype Model
1. Requirement Gathering and Analyst
2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product
Advantage of Prototype Model
1. Reduce the risk of incorrect user requirement
2. Good where requirement are changing/uncommitted
3. Regular visible process aids management
4. Support early product marketing
5. Reduce Maintenance cost.
6. 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
1. Costs customer money
2. Needs committed customer
3. Difficult to finish if customer withdraw
4. 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.
 Evolutionary Process Model
• Evolutionary process model resembles the iterative enhancement
model. The same phases are defined for the waterfall model occurs
here in a cyclical fashion. This model differs from the iterative
enhancement model in the sense that this does not require a useful
product at the end of each cycle. In evolutionary development,
requirements are implemented by category rather than by priority.
• For example, in a simple database application, one cycle might
implement the graphical user Interface (GUI), another file
manipulation, another queries and another updates. All four cycles
must complete before there is a working product available.
• GUI allows the users to interact with the system, file manipulation
allow the data to be saved and retrieved, queries allow user to get
out of the system, and updates allows users to put data into the
system.
 Benefits of Evolutionary Process Model
• Use of EVO brings a significant reduction in risk for software
projects.
• EVO can reduce costs by providing a structured, disciplined
avenue for experimentation.
• EVO allows the marketing department access to early
deliveries, facilitating the development of documentation and
demonstration.
• Better fit the product to user needs and market requirements.
• Manage project risk with the definition of early cycle content.
• Uncover key issues early and focus attention appropriately.
• 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.
• Today, software takes on a dual role.
• It is a product, and at the same time, the vehicle for delivering a product.
• As a product, it delivers the computing potential embodied by computer
hardware or more broadly, by a network of computers that are accessible
by local hardware.
• software is an information transformer.
• As the vehicle used to deliver the product, software acts as the basis for
the control of the computer (operating systems), the communication of
information (networks), and the creation and control of other programs
(software tools and environments).
• Software delivers the most important product of our
time—information. It transforms personal data (e.g., an individual’s
financial transactions) so that the data can be more useful in a local
context; it manages business information to enhance
competitiveness; it provides a gateway to worldwide information
networks (e.g., the Internet), and provides the means for acquiring
information in all of its forms.
DEFINING SOFTWARE:
Software is: (1) instructions (computer programs) that when executed
provide desired features, function, and performance; (2) data
structures that enable the programs to adequately manipulate
information, and (3) descriptive information in both hard copy and
virtual forms that describes the operation and use of the programs.
• software has characteristics that are considerably different than
those of hardware:
1. Software is developed or engineered,it is not manufactured in the
classical sense.
2. Software doesn’t “wear out.”
3. Although the industry is moving toward component-based
construction, most software continues to be custom built.
• SOFTWARE APPLICATION DOMAIN
Today, seven broad categories of computer software present
continuing challenges for software engineers:
System software
A collection of programs written to service other programs. Some
system software (e.g., compilers, editors, and file management
utilities). Other systems applications (e.g., operating system
components, drivers, networking software, telecommunications
processors) process largely indeterminate data.
• Application software—
Stand-alone programs that solve a specific business need. Applications
in this area process business or technical data in a way that facilitates
business operations or management/technical decision making. In
addition to conventional data processing applications, application
software is used to control business functions in real time (e.g., point-
of-sale transaction processing, real-time manufacturing process
control).
Legacy software
These older programs—often referred to as legacy software
Dayani-Fard and his colleagues [Day99] describe legacy software in the
following way:
Legacy software systems . . . were developed decades ago and have
been continually modified to meet changes in business requirements
and computing platforms. The proliferation of such systems is causing
headaches for large organizations who find them costly to maintain
and risky to evolve.
• one additional characteristic that is present in legacy software—poor
quality. Legacy systems sometimes have inextensible designs,
convoluted code, poor or nonexistent documentation, test cases and
results that were never archived, a poorly managed change history.