Shri Vaishnav Vidyapeeth Vishwavidyalaya, Indore

Shri Vaishnav Institute of information Technology

Department of computer science and Engineering

Year/ Semester – III/V

Subject Name – Software Engineering and Project Management
Subject Code – BTCS 504
Faculty Name – Mrs. Pallavi kala
UNIT 1
Software Engineering
Software ??
1) It refers to a program or set of collection of program and
applications used to manage & control various functions of a
device such as computer, unlike hardware, which represents a
physical part of a device.

2) Definition by Ian Somerville: Software products may be

developed for a particular customer or may be developed for a
general market.

3) Definition by Roger S Pressman: Software is a computer

program that when executed provide desired features, functions
& performance.

Data structure that enable the programs to adequately manipulate

inBfYo: Pram aitNiioganm.
ridh
Engineering
Application of science, tools & methods to find cost effective
solution to problems.
The output should be cost effective solution to that problem.
Engineering is all about developing products, using well
defined scientific methods & principles.

1. Ask What are

problems &
constraints

2. Imagine Ideas
5. Improve & choose best
software Engineering
one
Design
Process

4. Create &
follow the 3. Plan (draw a
BY: Paridhi Nigam
plan. Test it diagram)
out.
 Software +Engineering
The term software engineering is the product of two words, software,
and engineering.
The software is a collection of integrated programs.
Engineering is the application of scientific and practical knowledge to invent,
design, build, maintain, and improve frameworks, processes, etc.

Softw Engin
are + eering

Computer program or The process of

instructions that using knowledge
provides desired and principles to
functions and features design build and
when executed. analyze objects.

“TheBY:pPraroidcheiNssi gamofdeveloping and maintaining a software in a systematic

disciplined and quantifiable manner is called as Software Engineering”.
 Software Process
• 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:
• There are four basic key process activities:
• Software Specifications:
In this process, detailed description of a software system to be
developed with its functional and non-functional requirements.
• Software Development:
In this process, designing, programming, documenting, testing, and
bug fixing is done.
• Software Validation:
In this process, evaluation software product is done to ensure that
the software meets the business requirements as well as the end
users needs.
• Software Evolution:
It is a process of developing software initially, then timely updating
it for various reasons.
 Generic Process Model
• A software process is a collection of various activities.
There are five generic process framework activities:
1. Communication:
The software development starts with the communication
between customer and developer.
•
2. Planning:
It consists of complete estimation, scheduling for project
development and tracking.
• 3. Modeling:Modeling consists of complete requirement analysis and the
design of the project like algorithm, flowchart etc.
• The algorithm is the step-by-step solution of the problem and the flow
chart shows a complete flow diagram of a program.

• 4. Construction:Construction consists of code generation and the testing

part.
• Coding part implements the design details using an appropriate
programming language.

• Testing is to check whether the flow of coding is correct or not.

• Testing also check that the program provides desired output.

• .
• 5. Deployment: Deployment step consists of delivering the
product to the customer and take feedback from them.
• If the customer wants some corrections or demands for the
additional capabilities, then the change is required for
improvement in the quality of the software
 Process Assessment and Improvement
• Software processes are assessed to ensure their ability to
control the cost, time and quality of software. Assessment is
done to improve the software process followed by an
organization.

• Software Process Improvement (SPI) Cycle includes:

• Process measurement
• Process analysis
• Process change
There are several methods to assess software:
Standard CMMI Assessment Method for Process Improvement (SCAMPI)—provides a
five-step process assessment model : initiating, diagnosing, establishing, acting, and
learning.

CMM-Based Appraisal for Internal Process Improvement (CBA IPI)—provides a

diagnostic technique for assessing the relative maturity of a software organization.

SPICE (ISO/IEC15504)—a standard that defines a set of requirements for software

process assessment. The intent of the standard is to assist organizations in developing
an objective evaluation of the efficacy of any defined software process.

ISO 9001:2000 for Software—a generic standard that applies to any organization that
wants to improve the overall quality of the products, systems, or services that it provides.
• Different approaches towards process assessment include
• CMM (Capability Maturity Model) and CMMI (Capability Maturity Model
Integration)
• CMM was developed by SEI (Software Engineering Institute) and evolved
into CMMI later. It is an approach based on which an organization’s
process maturity is determined.
• CMM was developed by SEI (Software Engineering Institute) and evolved into CMMI later. It is an
approach based on which an organization’s process maturity is determined.
• CMM’s five maturity levels:
• Initial Level: Processes are not organized and the success of a project depends only on the
competence of the individual working on it. May not be able to repeat past successes in future
projects. The probability of exceeding the estimated cost and schedule is high.
• Repeatable Level: In this level, successes of the past could be repeated because the organization
uses project management techniques to track cost and schedule. Management according to a
documented plan helps in the improved process.
• Defined Level: Organization’s set of standard processes are defined and are slightly modified to
incorporate each project demands. This provides consistency throughout the works of the
organization.
• Managed Level: Management of processes using quantitative techniques improves performance.
Processes are assessed through data collection and analysis.
• Optimizing Level: Processes are monitored and improved through feedback from current work.
Innovative techniques are applied to cope with changing business objectives and the environment.
• CMMI capability levels include:
• Advertisements
• Level 0: Incomplete – Incomplete processes are processes that are not performed
or partially performed.
• Level 1: Performed – Specific goals are satisfied by processes and yet certain
objectives related to quality, cost and schedule are not met. Useful work can be
done.
• Level 2: Managed – Cost, quality and schedule are managed and processes are
monitored by management techniques.
• Level 3: Defined – It includes management and additionally follow the
organization’s specified set of standard processes which are altered for each
project.
• Level 4: Quantitatively Managed – Statistical and quantitative techniques are used
for the management of processes.
• Level 5: Optimized – It focuses on continuous improvement of Quantitatively
Managed process through innovations and nature of processes.
• A prescriptive process model is a model that describes "how to do"
according to a certain software process system.
• A prescriptive model prescribes how a new software system should be
developed. Prescriptive models are used as guidelines or frameworks to
organize and structure how software development activities should be
performed, and in what order.
Waterfall Model
• Waterfall Model is a sequential model that divides software
development into pre-defined phases. Each phase must be
completed before the next phase can begin with no overlap
between the phases. Each phase is designed for performing
specific activity during the SDLC phase. It was introduced in
1970 by Winston Royce.
Waterfall Model
• When to use SDLC Waterfall Model?
• Waterfall Methodology can be used when:
• Requirements are not changing frequently
• Application is not complicated and big
• Project is short
• Requirement is clear
• Environment is stable
• Technology and tools used are not dynamic and is stable
• Resources are available and trained
 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.
• 8M
• 194
• C++ vs Java
• 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.
Evolutionary Model
It is a combination of Iterative and Incremental model of software
development life cycle. Delivering your system in a big bang release,
delivering it in incremental process over time is the action done in this model.
Some initial requirements and architecture envisioning need to be done.

It is better for software products that have their feature sets redefined during
development because of user feedback and other factors. The Evolutionary
development model divides the development cycle into smaller, incremental
waterfall models in which users are able to get access to the product at the end
of each cycle.
Feedback is provided by the users on the product for the planning stage of the
next cycle and the development team responds, often by changing the product,
plan or process. Therefore, the software product evolves with time.

All the models have the disadvantage that the duration of time from start of the
project to the delivery time of a solution is very high. Evolutionary model
solves this problem in a different approach.
• Application of Evolutionary Model:
• It is used in large projects where you can easily find modules for
incremental implementation. Evolutionary model is commonly used when
the customer wants to start using the core features instead of waiting for
the full software.
• Evolutionary model is also used in object oriented software development
because the system can be easily portioned into units in terms of objects.
• Advantages:
• In evolutionary model, a user gets a chance to experiment partially
developed system.
• It reduces the error because the core modules get tested thoroughly.
• Disadvantages:
• Sometimes it is hard to divide the problem into several versions that
would be acceptable to the customer which can be incrementally
implemented and delivered.
Concurrent Model
The concurrent development model is called as concurrent model.
The communication activity has completed in the first iteration and exits in the
awaiting changes state.
The modeling activity completed its initial communication and then go to the
underdevelopment state.
If the customer specifies the change in the requirement, then the modeling activity
moves from the under development state into the awaiting change state.
The concurrent process model activities moving from one state to another state
Advantages
• This model is applicable to all types of software development
processes.
• It is easy for understanding and use.
• It gives immediate feedback from testing.
• It provides an accurate picture of the current state of a project.

Disadvantages
• It needs better communication between the team members. This
may not be achieved all the time.
• It requires to remember the status of the different activities.
 Specialized Process model
• Special process models take many features from one or more
conventional models. However these special models tend to
be applied when a narrowly defined software engineering
approach is chosen. Types in Specialized process models:
• 1. Component based development (Promotes reusable components)

• 2. The formal methods model (Mathematical formal methods are

backbone here)

• 3. Aspect oriented software development (Uses crosscutting technology)

Component base
• The component based development model
incorporates many of the characteristics of the spiral
model.
• It is evolutionary in nature, demanding an iterative
approach to the creation of software. However, the
model focuses on prepackaged software
components. It promotes software reusability
 Component Based Model

• The component based development model

incorporates many of the characteristics of the spiral
model. It is evolutionary in nature, Specialized
process model demanding an iterative approach to
the creation of software. However, the component
based development model constructs applications
from prepackaged software components.
• The model works in following manner:

• Step-1:
First identify all the required candidate components, i.e., classes with the help of application data
and algorithms.

• Step-2:
If these candidate components are used in previous software projects then they must be present in
the library.

• Step-3:
Such preexisting components can be excited from the library and used for further development.

• Step-4:
• But if the required component is not present in the library then build or create the component as
per requirement.
• Step-5:
• Place this newly created component in the library. This makes one iteration of the system.
• Step-6:
Repeat steps 1 to 5 for creating n iterations, where n denotes the number of iterations required to
develop the complete application.
Formal Method Model
• The formal methods model is an approach to software
engineering that applies mathematical methods or
techniques to the process of developing complex software
systems. The approach uses a formal specification language
to define each characteristic of the system. The language is
very particular and employs a unique syntax whose
components includes objects, relations, and rules.
• When used together, these components can validate the
correctness of each characteristic. Think of the process like
balancing a series of equations. At each step in the series, if
the right-side of the equation doesn't equal the left, there's
a problem that must be addressed.
• Formal Methods Model: Steps
• Formal methods comprise formal specification using
mathematics to specify the desired properties of the system.
Formal specification is expressed in a language whose syntax
and semantics are formally defined. This language comprises a
syntax that defines specific notation used for specification
representation; semantic, which uses objects to describe the
system; and a set of relations, which uses rules to indicate the
objects for satisfying the specification.
• Generally, the formal method comprises two approaches, namely,
property based and model-based. The property-based
specification describes the operations performed on the system. In
addition, it describes the relationship that exists among these
operations. A property-based specification consists of two parts:
signatures, which determine the syntax of operations and an
equation, which defines the semantics of the operations through a
set of equations known as axioms.
• The model-based specification utilizes the tools of set theory,
function theory, and logic to develop an abstract model of the
system. In addition, it specifies the operations performed on the
abstract model. The model thus developed is of a high level and
idealized. A model-based specification comprises a definition of the
set of states of the system and definitions of the legal operations
performed on the system to indicate how these legal operations
change the current state
Aspect-oriented software development

• Aspect-oriented software development (AOSD) is a software

design solution that helps address the modularity issues that
are not properly resolved by other software approaches, like
procedural, structured and object-oriented programming
(OOP). AOSD complements, rather than replaces, these other
types of software approaches.
• AOSD is also known as aspect-oriented programming (AOP).
Unified Process (RUP)

• Rational Unified Process (RUP) is a software development

process for object-oriented models. It is also known as the
Unified Process Model. It is created by Rational corporation
and is designed and documented using UML (Unified
Modeling Language). This process is included in IBM
Rational Method Composer (RMC) product. IBM
(International Business Machine Corporation) allows us to
customize, design, and personalize the unified process.
• Unified Process (RUP) has the following major characteristics:

• It is use-case driven
• It is architecture-centric
• It is risk focused
• It is iterative and incremental
• Phases of RUP :
There are total five phases of life cycle of RUP:
• Inception –
– Communication and planning are main.
– Identifies Scope of the project using use-case model allowing managers to estimate costs and
time required.
– Customers requirements are identified and then it becomes easy to make a plan of the
project.
– Project plan, Project goal, risks, use-case model, Project description, are made.
– Project is checked against the milestone criteria and if it couldn’t pass these criteria then
project can be either cancelled or redesigned.
• Elaboration –
– Planning and modeling are main.
– Detailed evaluation, development plan is carried out and diminish the risks.
– Revise or redefine use-case model (approx. 80%), business case, risks.
– Again, checked against milestone criteria and if it couldn’t pass these criteria then again
project can be cancelled or redesigned.
– Executable architecture baseline.
• Construction –
– Project is developed and completed.
– System or source code is created and then testing is done.
– Coding takes place.
• Transition –
– Final project is released to public.
– Transit the project from development into production.
– Update project documentation.
– Beta testing is conducted.
– Defects are removed from project based on feedback from public.
• Production –
– Final phase of the model.
– Project is maintained and updated accordingly.
 Personal and Team Process Model
• The best software process is personal and team process
model one that is close to the people who will be doing the
work. Watts Humphrey proposed two process models. Models
“Personal Software Process (PSP)” and “Team Software
Process (TSP).” Both require hard work, training, and
coordination, but both are achievable.
 Personal Software Process (PSP)
• The Personal Software Process (PSP) emphasizes
personal measurement of both the work product that is produced and the
resultant quality of the work product. In addition PSP makes the
practitioner responsible for project planning and empowers the
practitioner to control the quality of all software work products that are
developed. The PSP model defines five framework activities:
• Planning. This activity isolates requirements and develops both size and
resource estimates. In addition, defects estimate (the number of defects
projected for the work) is made. All metrics are recorded on worksheets or
templates. Finally, development tasks are identified and a project schedule
is created.
• High level design. External specifications for each component to be
constructed are developed and a component design is created. Prototypes
are built when uncertainty exists. All issues are recorded and tracked.
• High level design review. Formal verification methods are applied to
uncover errors in the design. Metrics are maintained for all important
tasks and work results.

• Development. The component level design is refined and reviewed. Code

is generated, reviewed, compiled, and tested. Metrics are maintained for
all important tasks and work results.

• Postmortem. Using the measures and metrics collected, the effectiveness

of the process is determined. Measures and metrics should provide
guidance for modifying the process to improve its effectiveness.
 Agile Development
• The Agile software development methodology is one of the
simplest and effective processes to turn a vision for a business
need into software solutions. Agile is a term used to describe
software development approaches that employ continual
planning, learning, improvement, team collaboration,
evolutionary development, and early delivery. It encourages
flexible responses to change.
The agile software development emphasizes on four core values.

• Individual and team interactions over processes and tools

• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan
• Individual interactions are more important than processes and
tools. People drive the development process and respond to business
needs. They are the most important part of development and should be
valued above processes and tools. If the processes or tools drive
development, then the team will be less likely to respond and adapt to
change and, therefore, less likely to meet customer needs.
• A focus on working software rather than thorough
documentation. Before Agile, a large amount of time was spent on
documenting the product throughout development for delivery. The list of
documented requirements was lengthy and would cause long delays in the
development process. While Agile does not eliminate the use of
documentation, it streamlines it in a way that provides the developer with
only the information that is needed to do the work -- such as user stories.
The Agile Manifesto continues to place value on the process of
documentation, but it places higher value on working software.
• Collaboration instead of contract negotiations. Agile focuses on
collaboration between the customer and project manager, rather than
negotiations between the two, to work out the details of delivery.
Collaborating with the customer means that they are included throughout
the entire development process, not just at the beginning and end, thus
making it easier for teams to meet the needs of their customers. For
example, in Agile software development, the customer may be included at
different intervals for demos of the product. However, the customer could
also be present and interacting with the teams on a daily basis, attending
all meetings and ensuring the product meets their desires.
• A focus on responding to change. Traditional software development used
to avoid change because it was considered an undesired expense. Agile
eliminates this idea. The short iterations in the Agile cycle allow changes
to easily be made, helping the team modify the process to best fit their
needs rather than the other way around. Overall, Agile software
development believes change is always a way to improve the project and
provide additional value.
• Collaboration between the business stakeholders and developers throughout the project – Better
decisions are made when the business and technical team are aligned.
• Support, trust, and motivate the people involved – Motivated teams are more likely to deliver
their best work than unhappy teams.
• Enable face-to-face interactions – Communication is more successful when development teams are
co-located.
• Working software is the primary measure of progress – Delivering functional software to the
customer is the ultimate factor that measures progress.
• Agile processes to support a consistent development pace – Teams establish a repeatable and
maintainable speed at which they can deliver working software, and they repeat it with each
release.
• Attention to technical detail and design enhances agility – The right skills and good design ensures
the team can maintain the pace, constantly improve the product, and sustain change.
• Simplicity – Develop just enough to get the job done for right now.
• Self-organizing teams encourage great architectures, requirements, and designs – Skilled and
motivated team members who have decision-making power, take ownership, communicate
regularly with other team members, and share ideas that deliver quality products.
• Regular reflections on how to become more effective – Self-improvement, process improvement,
advancing skills, and techniques help team members work more efficiently.
 Extreme Programming (XP)

• XP is a lightweight, efficient, low-risk, flexible, predictable, scientific, and

fun way to develop a software.

• eXtreme Programming (XP) was conceived and developed to address the

specific needs of software development by small teams in the face of
vague and changing requirements.
• Extreme Programming is one of the Agile software development
methodologies. It provides values and principles to guide the team
behavior. The team is expected to self-organize. Extreme Programming
provides specific core practices where −
• Each practice is simple and self-complete.
• Combination of practices produces more complex and emergent behavior.
 Extreme Programming Advantages

• Slipped schedules − and achievable development cycles ensure timely deliveries.

• Cancelled projects − Focus on continuous customer involvement ensures

transparency with the customer and immediate resolution of any issues.

• Costs incurred in changes − Extensive and ongoing testing makes sure the changes
do not break the existing functionality. A running working system always ensures
sufficient time for accommodating changes such that the current operations are
not affected.
• Production and post-delivery defects: Emphasis is on − the unit tests to detect
and fix the defects early.
• Misunderstanding the business and/or domain − Making the customer a part of
the team ensures constant communication and clarifications.
• Business changes − Changes are considered to be inevitable and are
accommodated at any point of time.
• Staff turnover − Intensive team collaboration ensures enthusiasm and good will.
Cohesion of multi-disciplines fosters the team spirit.
 Values of extreme programming methodology

• XP is more than just a series of steps to manage projects—it follows a set of values that will help your
team work faster and collaborate more effectively.

•
Simplicity
• Teams accomplish what has been asked for and nothing more. XP breaks down each step of a
major process into smaller, achievable goals for team members to accomplish.
• Streamlined communication
• Teams work together on every part of the project, from gathering requirements to
implementing code, and participate in daily standup meetings to keep all team members
updated. Any concerns or problems are addressed immediately.
• Consistent, constructive feedback
• In XP, teams adapt their process to the project and customer needs, not the other way
around. The team should demonstrate their software early and often so they can gather
feedback from the customer and make the necessary changes.
• Respect
• Extreme programming encourages an “all for one and one for all” mentality. Each person on
the team, regardless of hierarchy, is respected for their contributions. The team respects the
opinions of the customers and vice versa.
• Courage
• Team members adapt to changes as they arise and take responsibility for their work. They tell
the truth about their progress—there are no “white lies” or excuses for failure to make
people feel better. There’s no reason to fear because no one ever works alone.
 Scrum
• Scrum is the type of Agile framework. It is a framework
within which people can address complex adaptive problem
while productivity and creativity of delivering product is at
highest possible values. Scrum uses Iterative process.

• Silent features of Scrum are:

• Scrum is light-weighted framework
• Scrum emphasizes self-organization
• Scrum is simple to understand
• Scrum framework help the team to work together