The document discusses several software process models including: 1) The waterfall model which is linear and sequential with distinct stages of requirements, design, implementation, testing, and maintenance. 2) Evolutionary/iterative models which allow for incremental development and changes during the process. 3) Component-based development which focuses on reuse of existing software components. 4) Agile methodologies like Scrum and Extreme Programming (XP) which emphasize adaptive planning, evolutionary development, and customer collaboration.

1. What are the different types of
Software Process Model?

2. SW Process Models
• Waterfall model
• Evolutionary or Progressive models
• Component-based development model
• Iterative Model
• Agile Methodology
2

3. Types of Agile Methodology
• Extreme Programming (XP)
• Scrum
• Agile Modeling
• Agile Unified Process (AUP)
• Dynamic Systems Development Method (DSDM)
• Essential Unified Process (EssUP)
• Exia Process (ExP)
• Feature Driven Development (FDD)
• Open Unified Process (OpenUP)
• Crystal Clear
• Velocity tracking

4. Waterfall model
• History
• Characteristic
• Advantages
• Disadvantages

5. The Waterfall Model
• Oldest model, it’s been around since 1970.
• Called “Linear Sequential Model”.
• Most widely used model for SW engineering
• Documentation is produced at each stage.
5

6. Phases
1. Requirements analysis and definition
2. System and software design
3. Implementation and unit testing
4. Integration and system testing
5. Operation and maintenance
6

7. Waterfall model diagram

8. Disadvantages
• Inflexible partitioning of the project into distinct stages
makes it difficult to respond to changing customer
requirements.
• Only appropriate when the requirements are well-
understood and changes will be fairly limited during
the design process.
• The waterfall model is mostly used for large systems
engineering projects.
8

9. What are Evolutionary Models

10. Evolutionary Models
10

11. What are Exploratory Models
• Features
• Advantages
• Disadvantages

12. The Exploratory Model
Objective is to work with customers and evolve a
final system from an initial outline specification.
Should start with well-understood requirements
and add new features as proposed by the
customer.

13. The Exploratory Model
Concurr ent
activities
Initial
Specification version
Outline Intermedia te
description Development versions
Final
Valida tion version
13

14. The Exploratory Model
• Problems
– Lack of process visibility;
– Systems are often poorly structured;
• Applicability
– For small or medium-size interactive systems;
– For parts of large systems (e.g. the user interface);
– For short-lifetime systems.
14

15. What are Prototyping Models
• Features
• Advantages
• Disadvantages

16. The Prototyping Model
When a customer defines a set of general objectives
for a software but does not identify detailed input,
processing, or output requirement.
It consists of the iterating phases:
1. Requirements gathering
2. Design and build SW prototype
3. Evaluate prototype with customer
4. Refine requirements
16

17. The Prototyping Model
17

18. The Prototyping Model
• Advantages
– Users get a feel for the actual system
– Developers get to build something immediately
– Specifications can be developed incrementally
• Disadvantages
– The developer may make implementation compromises in
order to get a prototype working quickly.
– The process in not visible (few documents that reflect every
version of the system)
– Systems poorly structured
18

19. What is Component Based
Software Engineering (CBSE)
• Features
• Advantages
• Disadvantages

20. Component Based Software
Engineering (CBSE)
• Based on systematic reuse where systems are
integrated from existing components.
• Process stages
– Component analysis;
– Requirements modification;
– System design with reuse;
– Development and integration.
• This approach is becoming increasingly used as
component standards have emerged.
20

21. Component Based Software
Engineering (CBSE)
Requirements Component Requirements System design
specification analy sis modification with reuse
Development Sy stem
and integ ration validation
21

22. Component Based Software
Engineering (CBSE)
• Advantages:
– Reduce amount of software to be developed
– Reduce costs and risks
– Faster delivery
• Disadvantages:
– Requirements compromises, system does not meet real
needs of users
– Limited features
22

23. Iterative Model and its Types

24. Iterative Models
24

25. Advantages and Disadvanates
• Incremental Model
• Spiral Model
• Agile Model

26. The Incremental Model
Rather than deliver the system as a single delivery, the
development and delivery is broken down into
increments with each increment delivering part of the
required functionality.
User requirements are prioritised and the highest priority
requirements are included in early increments.
Once the development of an increment is started, the
requirements are frozen though requirements for later
increments can continue to evolve.

27. The Incremental Model
Define outline Assign requirements Design sy stem
requirements to increments architectur e
Develop sy stem Valida te Integ rate Validate
increment increment increment sy stem
Final
sy stem
Sy stem incomplete
27

28. The Incremental Model
Advantages:
• Customer value can be delivered with each increment so
system functionality is available earlier.
• Early increments act as a prototype to help elicit
requirements for later increments.
• Lower risk of overall project failure.
• The highest priority system services tend to receive the
most testing.
28

29. The Incremental Model
Disadvantages:
• Increments should be relatively small (20,000 lines of
code)
• Can be difficult to map the customer’s requirements
onto increments of the right size
• Hard to identify common functions
29

30. The Spiral Model
• Defined by Barry Boehm in his 1988 article A Spiral
Model of Software Development and Enhancement.
• Process is represented as a spiral rather than as a
sequence of activities with backtracking.
• Each loop in the spiral represents a phase in the
process.
• Suitable for large, expensive and complicated projects
30

31. The Spiral Model
Deter mine objecti ves,
Evalua te alterna tives,
alterna tives and
identify, resolv e risks
constr aints Risk
anal ysis
Risk
anal ysis
Risk
Oper a-
anal ysis
Pr ototype 3 tional
Prototype 2 protoype
Risk
REVIEW anal ysis Proto-
type 1
Requir ements plan Simula tions , models , benchmar ks
Life-cy cle plan Concept of
Oper a tion S/W
requir ements Product
design Detailed
Requir ement design
De velopment
plan valida tion Code
Unit test
Integ ra tion Design
V&V Integ ra tion
and test plan
Plan ne xt phase test
Acceptance 31
Service test De velop , verify
ne xt-le vel pr oduct

32. The Spiral Model
Advantages:
• Risks are explicitly assessed and resolved throughout
the process.
• Software engineers can start working on the project
earlier rather than wading through a lengthy early
design process.
32

33. The Spiral Model
Disadvantages:
• Requires highly skilled people in risk analysis and
planning
• Requires more time, and is more expensive
• Estimates of budget and time are harder to judge at
the beginning of the project since the requirements
evolve through the process
33

34. Latest Techniques of Software Process
Management (SPM)
AGILE & EXTREME
PROGRAMMING

35. Covered Topics
• What is Agile Programming
• What is Extreme Programming (XP)
• Why would I use Extreme Programming?
• Values of XP
• Principals of XP
• Activities of XP
• Dangers of XP

36. What is “Agility”?

37. What is “Agility”?
• Effective (rapid and adaptive) response to
change
• Effective communication among all
stakeholders
• Drawing the customer onto the team
Yielding …
• Rapid, incremental delivery of software
SWE 418 (062) Agile Software Processes-XP 37

38. Agile properties

39. The Agile Manifesto–a statement of
values
Individuals and
Individuals and over Process and tools
Process and tools
interactions
interactions
Comprehensive
Comprehensive
Working software
Working software over
documentation
documentation
Customer collaboration
Customer collaboration over Contract negotiation
Contract negotiation
Responding to change
Responding to change over Following a plan
Following a plan
Source: www.agilemanifesto.org

40. Agile properties
• Other Models • Agile
• Predictive • Adaptive
• Process-Oriented • People-Oriented

41. Characteristics of an Agile process

42. An Agile process
• Is driven by customer descriptions of what is
required (Scenarios)(User Stories)
• Recognizes that plans are short-lived
• Develops software iteratively with a heavy
emphasis on construction activities
• Delivers multiple ‘software increments’
• Adapts as changes occur
SWE 418 (062) 42

43. Basic Building Blocks of
Agile Software Development

44. Basic Building Blocks of
Agile Software Development
 Individuals and interactions over processes and tools;
 Working software over comprehensive documentation;
 Customer collaboration over contract negotiation;
 Responding to change over following a plan.

45. What Is Extreme Programming?

46. Definition
What Is Extreme Programming?
“Extreme Programming (XP) is one of a growing group of
agile software development methodologies. XP uses
integrated teams of programmers, customers, and
managers to develop high-quality software at high speed”.
XP Team
Programmers Customers Managers

47. Definition
• Extreme Programming differs from traditional
methodologies primarily in placing a higher value on
adaptability than on predictability.
• In XP “Working software is the primary measure of
progress.”

48. Other Agile Processes
• The Crystal Methodology Family:
crystalmethodologies.org
• Scrum:
www.controlchaos.com
• Adaptive Software Development: www.adaptivesd.com
• DSDM (Dynamic System Development Method):
www.dsdm.org

49. What is different in XP

50. XP is Different
• Early, concrete, and continuous feedback from
short-cycles.
• Incremental planning approach.
• Flexibility of scheduling the implementation based
on changing business needs.
• Reliance on tests written by the programmers.
• Reliance on the collaboration of programmers.
SWE 418 (062) Agile Software Processes-XP 50

51. What are the Core XP Practices

52. The Core XP Practices
Rapid, fine feedback: Shared Understanding:
 Test-driven design (via unit and – Simple Design
acceptance tests) – Collective Code Ownership
 On-site customer – Coding Conventions
 Pair programming
Continuous process: Developer Welfare:
 Continuous integration  Forty-hour week
 Merciless refactoring
 Small, frequent releases

53. Compare
• Waterfall
• Iterative
• XP

54. Software Processes
Waterfall Iterative XP
Analysis
Design
Code
Test
Kent Beck 1999
SWE 418 (062) Agile Software Processes-XP 54

55. Waterfall method
Agile Development
process

56. Responsibilities of….
• Customer
• Team
• Developer Pair

57. “Circles of Life” On-site Customer
Coding Metaphor
Standards Refactoring
Customer Team Developer Pair – Team – Custome
Acceptance Unit Tests Pair Release
Tests Programming Planning
Continuous Collective
Integration Simple Design Ownership
Sustainable
Pace
Small Releases

58. Steps of XP

59. Steps of XP

60. The XP Key Points
• Find ways to make change cheaper
• Find inexpensive ways of avoiding errors
• Reduce overall cost of development

61. Thinking of Extreme Programming
• The main aim of XP is to reduce the cost of change.
• In traditional system development methods the requirements
for the system are determined at the beginning of the
development project and often fixed from that point on.
• This means that the cost of changing the requirements at a
later stage (a common feature of software engineering
projects) will be high.

62. Traditional Development exponential
curve vs. Extreme Programming Curve

63. Why would I use Extreme
Programming?
• Most software projects use an ad-hoc approach to
development known as “code and fix".
• Several studies have found that 40% to 80% of a typical
software project's budget goes into fixing defects that were
created earlier on the same project.
• So to lower this curve of change XP is used.

64. Why would I use Extreme
Programming?
• “Requirements-Analysis-Design-Code-Test-maintain” as a
assembly line.
 Assumption that the shape of the finished product is
known before the process begins.
• But, if a customer specify something completely new and
needs constant feedback to validate their choices. Then XP
comes into scene.

65. Activities of Extreme Programming
• Listening : For the programmers to find what the
functionality of the system should be, they have to listen to
business.
• Designing :One can come a long way without designing but
at a given time one will get stuck. The system becomes too
complex and there may be dependencies within the system.
XP Milestones
Listening Designing Coding Testing

66. Activities of Extreme Programming
• Coding : The only truly important product of the system
development process is code (a concept to which they give a
somewhat broader definition than might be given by others).
Without code you have nothing.
• Testing: One cannot be certain of anything unless one has
tested it.
XP Milestones
Listening Designing Coding Testing