1. Chapter-(Software Process)
Chapter-2 (Pressman)
Chapter-3 (Sommerville)

2. Simple life cycle model
Planning and Requirement Definition
Deployment & Maintenance
Analysis/ Specification
SDLC
Design
Testing
Implementation/ Coding

3. SDLC Phases Requirement Definition Phase/ Planning and Requirement
Analysis Phase/ Specification
Design
Implementation/ Coding
Testing/ Verification and Validation
Deployment and Maintenance/ Operation/ Use

4. Types of Software Process Models/ SDLC Life Cycle Models
Linear Sequential /Waterfall model/Classic life cycle model
Evolutionary Model
Prototyping Model
Incremental Model
Spiral Model / (5.a)WinWin spiral
Rapid Application and Development (RAD) Model
Concurrent Development Model
Component-Based / Reuse driven development (RDD)/ Reuse oriented
Formal method model
Fourth Generation (4GT) Techniques
V software life-cycle model
Synchronize-and-stabilize life-cycle model
Agile Model
Rational Unified Model (RUM)/RUP(process)
XP (Extreme Programming)

5. Waterfall model/Linear Sequential model/ Classical life cycle model(s-45)
Fig. Waterfall Model

6. Waterfall Model Characteristics
The classic life cycle - oldest and most widely used paradigm
Activities ‘flow’ from one phase to another
If there are corrections, return to a previous phase and ‘flow’ from there again
Major advantages: Good for planning and well-defined/repeated projects
See more from book

7. Waterfall Model (contd)
Characterized by
Activities ‘flow’ from one phase to another. Here, steps (phases) are arranged in linear order
Documentation-driven
Liked by managers
Advantages
Documentation associated with each phase
Maintenance is easier
Disadvantages
Too rigid; developers cannot move between various abstraction levels
Specification document hard for customer to understand
No feedback from the customer until the end 7

8. Problems of Waterfall Model
Real projects often follow the sequence
All requirements may not be stated explicitly by customer
Customer only sees the results after some time
Developers are often delayed at certain phases

9. 2. Evolutionary development model (s-47)
It is based on the idea of developing an initial implementation, exposing this to user comment and refining this through many versions until an adequate system has been developed.

10. Evolutionary Development……
Main characteristics:
The phases of the software construction are interleaved
Loops, or releases, tend to overlap each other: As testing and preparations for deployment of one release are underway, planning for the next release has already started
Types of evolutionary development:
Exploratory development
Throw-away prototyping 10

11. Evolutionary….

12. Evolutionary Development…
Advantages:
Deals constantly with changes
Provides quickly an initial version of the system
Involves all development teams
Disadvantages:
“Invisible” process, not well-supported by documentation
The system’s structure can be corrupted by continuous change
Special tools and techniques may be necessary 12

13. Prototype development
Requirements
gathering and
refinement
Building
prototype
Quick
design
Customer
evaluation
Refining
Engineer
product
Start
Stop

14. Prototyping Model Characteristics
Developer and customer determine objectives and draft requirements
Prototype quickly produced and evaluated by customer
Prototype then refined, and re-evaluated
Process iterated, before final product development
Advantages: Customer participation and better requirements

15. Problems of Prototyping Model
Problem 1: Customer may see prototype as working model and expects fast results
Problem 2: Developer compromised when producing prototype quickly, e.g. different operating system or programming language

16. Prototyping Model (rapid prototype build+ then waterfall)16

17. Rapid Prototyping Model (cont.)
Linear model
First step: “rapid” prototype
Advantages
Validation from customer
Insight to developers
Disadvantages
Client expectations
Poor design possibility – must throw away 17

18. Prototyping Model Characteristics
Quick design focuses on aspects visible to user; features clearly understood need not be implemented
Prototype is tuned to satisfy customer needs. Many iterations may be required to incorporate changes and new requirements
Final product follows usual define-design-build-test life cycle
Prototyping using requires an experienced team

19. Two Types of Prototyping
Throwaway prototyping: the n-th prototype is followed by a waterfall-like process (as depicted on previous slide)
Begin with the least-understood requirements
Evolutionary prototyping: the nth prototype is delivered
Begin with the best-understood requirements 19
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 19 19

20. Prototyping- Recommendations
The users and the designers must be well aware of the issues and the pitfalls
Prototyping using requires an experienced team
Use prototyping when the requirements are unclear
Prototyping is particularly useful for systems with a considerable emphasis on the user interface
Prototyping needs to be planned and controlled 20
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 20 20

21. Major Two Types of Prototyping
1. Evolutionary prototyping/incremental
The objective is to deliver a working system to end-users
The development starts with those requirements which are best understood and which have highest priority.
2. Throwaway/Rapid prototyping
The prototyping process starts with those requirements which are poorly understood in order to find out more about them.
© SE, Lifecycle, Hans van Vliet 21 21

22. Difference between evolutionary and throwaway prototyping
Book sommer

23. The process of prototype development
May be based on rapid prototyping languages or tools
May involve leaving out functionality
Prototype should focus on areas of the product that are not well-understood;
Error checking and recovery may not be included in the prototype;
Focus on functional rather than non-functional requirements such as reliability and security

24. Incremental Model(p-41)

25. Incremental Model Characteristics
Software separated into different “increments” - complete working portions
Focus on delivery of operational product with each increment - can be evaluated
Useful when insufficient staff and can be planned to manage technical risks, e.g. waiting for new hardware

26. Original Incremental Model
Divide project into builds
Advantages
Early delivery
More flexible
Disadvantages
Requires open architecture

27. Spiral Model (Full Form) (sommer)
Developed by Barry Boehm in 1986
Precede each phase by
Alternatives
Risk analysis
Follow each phase by
Evaluation
Planning of the next phase
Radial dimension: cumulative cost to date
Angular dimension (see dashed lines): progress through the spiral 27

28. Full Spiral Model (cont)(s-53)28

29. Spiral model sectors
Objective setting: Specific objectives for the phase are identified
Risk assessment and reduction: Risks are assessed and activities put in place to reduce the key risks
Development and validation: A development model for the system is chosen which can be any of the generic models
Planning: The project is reviewed and the next phase of the spiral is planned

30. Spiral Model Main characteristics:
Also a hybrid model that support process iteration
The process is represented as a spiral, each loop in the spiral representing a process phase
Four sectors per loop: objective setting, risk assessment and reduction, development and validation, planning
Risk is explicitly taken into consideration 30

31. Spiral Model Advantages: Disadvantages: Applicability:
Risk reduction mechanisms are in place
Supports iteration and reflects real-world practices
Systematic approach
Disadvantages:
Requires expertise in risk evaluation and reduction
Complex, relatively difficult to follow strictly
Applicable only to large systems
Applicability:
Internal development of large systems 31

32. Spiral Model(pressman)
Evolutionary approach that couples iterative nature of prototyping and systematic aspects of linear models.
Provides for rapid development of incremental versions of software.
Software is developed in series of incremental releases.
Each area in the diagram represents a set of tasks required. In all areas umbrella activities are applied.

33. Spiral model sectors/task region
Customer communication: tasks required to establish effective communication between developer and customer.
Planning: tasks required to define resources, timelines, and project related information.
Risk assessment and reduction :Risks are assessed and activities put in place to reduce the key risks
Engineering: tasks required to build one or more representations of the application
Construction and release: tasks required to construct, test, install and provide user support.
Customer evaluation: tasks required to obtain customer feedback.

34. WinWin Spiral Model Write description from pressman
Evolutionary approach that couples iterative nature of prototyping and systematic aspects of linear models.
Provides for rapid development of incremental versions of software.
Software is developed in series of incremental releases.
Each area in the diagram represents a set of tasks required. In all areas umbrella activities are applied.

35. Spiral Model (Simplified form)
Rapid prototyping model plus risk analysis preceding each phase
Key point
If all risks cannot be mitigated, the project is immediately terminated 35

36. Spiral Model

37. Spiral Model Characteristics
Originally proposed by Boehm, couples iterative nature of prototyping and the systematic aspects of waterfall model
Software is developed in series of incremental releases
Each iteration produces a more complete product
Better management through risk analysis

38. Problems of Spiral Model
May be difficult to convince customers that evolution is controllable
Demands risk assessment expertise - major risk will cause problems if not identified
Relatively new and not widely used - cannot determine performance

39. Component Assembly Characteristics
Use of object-oriented technology
Components - classes that encapsulate both data and algorithms
Components developed to be reusable
Paradigm similar to spiral model, but engineering activity involves components
System produced by assembling the correct components

40. Component-based Software Engineering40

41. Component Assembly Model
Extract
components
yes
Identify
candidate
components
Look up
components
in library
Available?
Construct
System no
Build
components

42. Component Assembly Characteristics
Use of object-oriented technology
Components - classes that encapsulate both data and algorithms
Components developed to be reusable
Paradigm similar to spiral model, but engineering activity involves components
System produced by assembling the correct components

43. Component-based Software Engineering..
Main characteristics:
Makes intensive use of existing reusable components
The focus is on integrating the components rather than on creating them from the scratch
Advantages:
Reduces considerably the software to be developed “in-house”
Allows faster delivery
In principle, more reliable systems, due to using previously tested components 43

44. Component-based Software Engineering
Disadvantages:
Compromises in requirements are needed
Less control over the system’s evolution
Applicability:
When there is a pool of existing components that could satisfy the requirements of the new product
Emerging trend: integration of web services from a range of suppliers 44

45. Reuse-oriented development (sommer)
Based on systematic reuse where systems are integrated from existing components or COTS

46. Reuse-oriented development
Based on systematic reuse where systems are integrated from existing components or COTS (Commercial-off-the-shelf) systems
Process stages
Component analysis
Requirements modification
System design with reuse
Development and integration
This approach is becoming more important but still limited experience with it

47. Formal transformations model(s-48)

48. 10. Fourth Generation Techniques (4GT)

49. 4GT Characteristics
Use of software tools that allow software engineer to specify s/w characteristics at higher level
The tools generate codes based on specification
More time in design and testing - increase productivity
Tools may not be easy to use, codes generated may not be efficient

50. Fourth Generation Characteristics (pressman-46)
The term fourth generation techniques (4GT) encompasses a broad array of software tools that have one thing in common: each enables the software engineer to specify some characteristic of software at a high level.
The tool then automatically generates source code based on the developer's specification.

51. Fourth Generation tools
software development environment that supports the 4GT paradigm includes some or all of the following tools:
nonprocedural languages for database query, report generation, data manipulation, screen interaction and definition, code generation; high-level graphics capability; spreadsheet capability, and automated generation of HTML and similar languages used for Web-site creation using advanced software tools

52. 4GT Characteristics
Use of software tools that allow software engineer to specify s/w characteristics at higher level
The tools generate codes based on specification
More time in design and testing - increase productivity
Tools may not be easy to use, codes generated may not be efficient

53. 3. V Model: A High-Level View
Level of Detail of V & V Testing
Requirements
Elicitation
Acceptance
Testing
Low
Problem with V-Model:
Client’s Perception is the same as the
Developer’s Perception
System
Testing
Analysis
The V-model is a variation of the waterfall model that makes explicit the dependency between development activities and verification activities. The difference between the waterfall model and the V model is that the latter makes explicit the notion of level of abstraction. Allactivities from requirements to implementation focus on building more and more detailed representation of the system, whereas all activities from implementation to operation focus on validating the system.
Design
Integration Testing
Object Design
Unit Testing
High
Project Time 53 53

54. From the Waterfall Model to the V Model
System
Testing
Unit
Integration
Acceptance
Requirements
Engineering
Requirements
Analysis
System Design
Object Design
Implemen-
tation
Integration Testing
System
Testing
Unit 54 54

55. V & V Planning
Careful planning is required to get the most out of testing and inspection processes.
Planning should start early in the development process.
The plan should identify the balance between static verification and testing.
Test planning is about defining standards for the testing process not only describing product tests. 55 55

56. Analysis of the V Model Characteristics Advantages Disadvantages
Alternate version of Waterfall Model
Distinguishes between development and V & V activities
Advantages
Test plans created early in the development life cycle
Acceptance test (validation) plans during requirements analysis
System integration test plans during system architecture development
Disadvantages
Shortcomings of the regular Waterfall Model
Does not support iteration 56

57. 6. Synchronize-and Stabilize Model
Microsoft’s life-cycle model (1997)
Requirements analysis — interview potential customers
Draw up specifications
Divide project into 3 or 4 builds
Each build is carried out by small teams working in parallel 57

58. Synchronize-and Stabilize Model (contd)
At the end of the day — synchronize
(test and debug)
At the end of the build — stabilize
(freeze the build)
Components always work together
Get early insights into the operation of the product 58

59. Analysis of Microsoft’s Model
Strengths
Future users needs are better met
Ensures components can be successfully integrated
Weaknesses
Has not been widely used other than at Microsoft 59

60. RAD: Rapid Application Development
evolutionary development, with time boxes: fixed time frames within which activities are done;
time frame is decided upon first, then one tries to realize as much as possible within that time frame;
other elements: Joint Requirements Planning (JRD) and Joint Application Design (JAD), workshops in which users participate;
requirements prioritization through a triage;
development in a SWAT team: Skilled Workers with Advanced Tools
Triage: split requirements in 3 sets: to be done now, to be done later, and things that will be done now if time permits it.
SWAT teams are discussed in chapter 5 as well, a bit.
RAD has much in common with the Scandinavian school, because they both value the role of users in the development process. 60
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 60 60

61. The Triage Process
The result of this process is often a prioritization denoted by the acronymn MoSCoW
Must haves are requirements that are definitely needed.
Should haves are requirements that are important, but not absolutely needed for a usable system
Could haves are requirements that are only implemented if time allows.
Won’t haves are requirements that will be left for the next iteration. 61

62. The RAD Model

63. Rapid Application Development (RAD)
Business
Modeling
Data
Process
Application
Generation
Testing &
Turnover
Team #1
Team #2
Time period

64. RAD Characteristics “High-speed” version of waterfall model
Primarily for information systems applications
Requirements well-understood, fully functional system produced in short time
The application modularised - major functions can be completed in 3 months
Separate teams complete the functions, then integrated as a whole
Requires human resource and commitment

65. Concurrent model (Pressman-43)

66. The Rational Unified Process(RUP)66

67. The Unified Process (UP)

68. The Phases of the Unified Process
In the figure, the increments are identified as phases

69. The Workflows (Disciplines) of the Unified Process (contd)
Sequential phases do not exist in the real world
Instead, five core workflows (activities) are performed over the entire life cycle as stated in Schach
Requirements workflow
Analysis workflow
Design workflow
Implementation workflow
Test workflow
The actual core workflows as listed in Larman are: Business Modeling, Requirements, Design, Implementation, and Test

70. The Workflows (Disciplines) of the Unified Process (contd)
In addition to the five core disciplines, the Unified Process includes other disciplines
Deployment
Configuration and Change Management
Project Management
Environment

71. More on Disciplines
The five core disciplines are performed over the entire life cycle
However, at any one time, one discipline predominates
Examples:
At the beginning of the life cycle
The business modeling and requirements disciplines predominate
At the end of the life cycle
The implementation and test disciplines predominate
Planning and documentation activities are performed throughout the life cycle

72. The Phases of the Unified Process
In the figure, the increments are identified as phases

73. Major work products in UP phases
Inception phase
Vision doc, early use cases, feasibility, project plans
Elaboration phase
Detailed use cases, analysis, architecture design, detailed plan, preliminary user manual
Construction phase
Detailed design, components, test plans/cases, implementation, detailed manuals
Transition phase
Delivery, beta/acceptance, user feedback

74. RUP good practice/Characteristics
Develop software iteratively
Plan increments based on customer priorities and deliver highest priority increments first.
Manage requirements
Explicitly document customer requirements and keep track of changes to these requirements.
Use component-based architectures
Organize the system architecture as a set of reusable components.
Visually model software
Use graphical UML models to present static and dynamic views of the software.
Verify software quality
Ensure that the software meet’s organizational quality standards.
Control changes to software
Manage software changes using a change management system and configuration management tools.

75. One- and Two-Dimensional Life-Cycle Models

76. Plan-driven and agile development
Plan-driven development
A plan-driven approach to software engineering is based around separate development stages with the outputs to be produced at each of these stages planned in advance.
Not necessarily waterfall model – plan-driven, incremental development is possible
Iteration occurs within activities.
Agile development
Specification, design, implementation and testing are inter-leaved and the outputs from the development process are decided through a process of negotiation during the software development process. 76

77. What is “Agility”? Effective (rapid and adaptive) response to change
Effective communication among all stakeholders
Drawing the customer onto the team
Organizing a team so that it is in control of the work performed
Rapid, incremental delivery of software

78. An Agile Process
Is driven by customer descriptions of what is required (scenarios)
Recognizes that plans are short-lived
Develops software iteratively with a heavy emphasis on construction activities
Delivers multiple ‘software increments’
Adapts as changes occur

79. The Agile Manifesto Individuals and interactions over
processes and tools
Working software over
comprehensive documentation
Customer collaboration over
contract negotiation
Responding to change over
following a plan
Agility: readiness for motion”, “nimbleness” (= behendigheid”) 79
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 79 79

80. The principles of agile methods
Description
Customer involvement
Customers should be closely involved throughout the development process. Their role is provide and prioritize new system requirements and to evaluate the iterations of the system.
Incremental delivery
The software is developed in increments with the customer specifying the requirements to be included in each increment.
People not process
The skills of the development team should be recognized and exploited. Team members should be left to develop their own ways of working without prescriptive processes.
Embrace change
Expect the system requirements to change and so design the system to accommodate these changes.
Maintain simplicity
Focus on simplicity in both the software being developed and in the development process. Wherever possible, actively work to eliminate complexity from the system.
Chapter 3 Agile software development 80

81. Chapter 3 Agile software development
Extreme programming
Perhaps the best-known and most widely used agile method.
Extreme Programming (XP) takes an ‘extreme’ approach to iterative development.
New versions may be built several times per day;
Increments are delivered to customers every 2 weeks;
All tests must be run for every build and the build is only accepted if tests run successfully.
Chapter 3 Agile software development 81

82. XP – eXtreme Programming
Everything is done in small steps
The system always compiles, always runs
Client as the center of development team
Begins with the creation of “user stories”
Agile team assesses each story and assigns a cost
Stories are grouped to for a deliverable increment
A commitment is made on delivery date
Ontstaan zo rond Maar bouwt naturlijk wel voort op eerdere ontwikkelingen: AD, evolutionair ontwikkelen ed, spiraal model, scandinavische school, fysische omgeving programmeurs, zoals onderzocht bij bv IBM (telefoon uit) 82
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 82 82

83. XP and agile principles
Incremental development is supported through small, frequent system releases.
Customer involvement means full-time customer engagement with the team.
People not process through pair programming, collective ownership and a process that avoids long working hours.
Change supported through regular system releases.
Maintaining simplicity through constant refactoring of code.
Chapter 3 Agile software development 83

84. The extreme programming release cycle84

85. 13 Practices of XP Whole team: client part of the team
Metaphor: common analogy for the system
The planning game, based on user stories
Simple design
Small releases (e.g. 2 weeks)
Customer tests
Pair programming
Test-driven development: tests developed first
Design improvement (refactoring)
Collective code ownership
Continuous integration: system always runs
Sustainable pace: no overtime
Coding standards
Voraf wel korte vorbereiding, met beetje architectuur, maar niet echt veel.
Team zonder bazen, met client er midden in
Metafoor: desktop bv.
Planning gebaseerd op scenarios, en soort “kunst”maat: bv story kost 4 bLUBS. En deze week maken we 20 BLUBS. Aan het eind van de week kijken of dat klopt, en je idee van de omvang van een BLUB bijstellen.
In design alleen stoppen wat je nodig hebt; de wereld verandert toch; aardige metFOO HIER: ELKE DAG KAART OPZETTEN EN WEER VOORSPELLEN, IPV EEN KEER PER WEEK.
Client evalueert elke release, en stelt zonodig bij; bepaalt prioriteiten volgende stories, etc.
Pair programming: piloot en copiloot; je kunt het van elkaar overnemen, enz.
Ipv eerst code schrijven, schrijf je eerst de tests
Overwerk leidt tot burnout, fouten, meer overwerk.
Team neemt een of andere standaard aan. 85
©2008 John Wiley & Sons Ltd.
vliet
© SE, Lifecycle, Hans van Vliet 85 85

86. Extreme programming practices (a)
Principle or practice
Description
Incremental planning
Requirements are recorded on story cards and the stories to be included in a release are determined by the time available and their relative priority. The developers break these stories into development ‘Tasks’. See Figures 3.5 and 3.6.
Small releases
The minimal useful set of functionality that provides business value is developed first. Releases of the system are frequent and incrementally add functionality to the first release.
Simple design
Enough design is carried out to meet the current requirements and no more.
Test-first development
An automated unit test framework is used to write tests for a new piece of functionality before that functionality itself is implemented.
Refactoring
All developers are expected to refactor the code continuously as soon as possible code improvements are found. This keeps the code simple and maintainable.
Chapter 3 Agile software development 86

87. Extreme programming practices (b)
Pair programming
Developers work in pairs, checking each other’s work and providing the support to always do a good job.
Collective ownership
The pairs of developers work on all areas of the system, so that no islands of expertise develop and all the developers take responsibility for all of the code. Anyone can change anything.
Continuous integration
As soon as the work on a task is complete, it is integrated into the whole system. After any such integration, all the unit tests in the system must pass.
Sustainable pace
Large amounts of overtime are not considered acceptable as the net effect is often to reduce code quality and medium term productivity
On-site customer
A representative of the end-user of the system (the customer) should be available full time for the use of the XP team. In an extreme programming process, the customer is a member of the development team and is responsible for bringing system requirements to the team for implementation.
Chapter 3 Agile software development 87

88. Chapter 3 Agile software development
Pair programming
In XP, programmers work in pairs, sitting together to develop code.
This helps develop common ownership of code and spreads knowledge across the team.
It serves as an informal review process as each line of code is looked at by more than 1 person.
It encourages refactoring as the whole team can benefit from this.
Measurements suggest that development productivity with pair programming is similar to that of two people working independently.
Chapter 3 Agile software development 88

89. Chapter 3 Agile software development
Pair programming
In pair programming, programmers sit together at the same workstation to develop the software.
Pairs are created dynamically so that all team members work with each other during the development process.
The sharing of knowledge that happens during pair programming is very important as it reduces the overall risks to a project when team members leave.
Pair programming is not necessarily inefficient and there is evidence that a pair working together is more efficient than 2 programmers working separately.
Chapter 3 Agile software development 89

90. Advantages of pair programming
It supports the idea of collective ownership and responsibility for the system.
Individuals are not held responsible for problems with the code. Instead, the team has collective responsibility for resolving these problems.
It acts as an informal review process because each line of code is looked at by at least two people.
It helps support refactoring, which is a process of software improvement.
Where pair programming and collective ownership are used, others benefit immediately from the refactoring so they are likely to support the process.
Chapter 3 Agile software development 90

91. Chapter 3 Agile software development91

92. Chapter-Agile Software Development92

93. Chapter 3 Agile software development
Topics covered
Agile methods
Plan-driven and agile development
Extreme programming
Agile project management
Scaling agile methods
Chapter 3 Agile software development 93

94. Rapid software development
Rapid development and delivery is now often the most important requirement for software systems
Businesses operate in a fast –changing requirement and it is practically impossible to produce a set of stable software requirements
Software has to evolve quickly to reflect changing business needs.
Rapid software development
Specification, design and implementation are inter-leaved
System is developed as a series of versions with stakeholders involved in version evaluation
User interfaces are often developed using an IDE and graphical toolset.
Chapter 3 Agile software development 94

95. Chapter 3 Agile software development
Agile methods
Dissatisfaction with the overheads involved in software design methods of the 1980s and 1990s led to the creation of agile methods. These methods:
Focus on the code rather than the design
Are based on an iterative approach to software development
Are intended to deliver working software quickly and evolve this quickly to meet changing requirements.
The aim of agile methods is to reduce overheads in the software process (e.g. by limiting documentation) and to be able to respond quickly to changing requirements without excessive rework.
Chapter 3 Agile software development 95

96. Chapter 3 Agile software development
Agile manifesto
We are uncovering better ways of developing 
software by doing it and helping others do it. 
Through this work we have come to value:
Individuals and interactions over processes and tools Working software over comprehensive documentation Customer collaboration over contract negotiation Responding to change over following a plan
That is, while there is value in the items on 
the right, we value the items on the left more.
Chapter 3 Agile software development 96

97. The principles of agile methods
Description
Customer involvement
Customers should be closely involved throughout the development process. Their role is provide and prioritize new system requirements and to evaluate the iterations of the system.
Incremental delivery
The software is developed in increments with the customer specifying the requirements to be included in each increment.
People not process
The skills of the development team should be recognized and exploited. Team members should be left to develop their own ways of working without prescriptive processes.
Embrace change
Expect the system requirements to change and so design the system to accommodate these changes.
Maintain simplicity
Focus on simplicity in both the software being developed and in the development process. Wherever possible, actively work to eliminate complexity from the system.
Chapter 3 Agile software development 97

98. Agile method applicability
Product development where a software company is developing a small or medium-sized product for sale.
Custom system development within an organization, where there is a clear commitment from the customer to become involved in the development process and where there are not a lot of external rules and regulations that affect the software.
Because of their focus on small, tightly-integrated teams, there are problems in scaling agile methods to large systems.
Chapter 3 Agile software development 98

99. Problems with agile methods
It can be difficult to keep the interest of customers who are involved in the process.
Team members may be unsuited to the intense involvement that characterises agile methods.
Prioritising changes can be difficult where there are multiple stakeholders.
Maintaining simplicity requires extra work.
Contracts may be a problem as with other approaches to iterative development.
Chapter 3 Agile software development 99

100. Agile methods and software maintenance
Most organizations spend more on maintaining existing software than they do on new software development. So, if agile methods are to be successful, they have to support maintenance as well as original development.
Two key issues:
Are systems that are developed using an agile approach maintainable, given the emphasis in the development process of minimizing formal documentation?
Can agile methods be used effectively for evolving a system in response to customer change requests?
Problems may arise if original development team cannot be maintained.
Chapter 3 Agile software development
100

101. Plan-driven and agile development
Plan-driven development
A plan-driven approach to software engineering is based around separate development stages with the outputs to be produced at each of these stages planned in advance.
Not necessarily waterfall model – plan-driven, incremental development is possible
Iteration occurs within activities.
Agile development
Specification, design, implementation and testing are inter-leaved and the outputs from the development process are decided through a process of negotiation during the software development process.
Chapter 3 Agile software development
101

102. Plan-driven and agile specification
Chapter 3 Agile software development
102

103. Technical, human, organizational issues
Most projects include elements of plan-driven and agile processes. Deciding on the balance depends on:
Is it important to have a very detailed specification and design before moving to implementation? If so, you probably need to use a plan-driven approach.
Is an incremental delivery strategy, where you deliver the software to customers and get rapid feedback from them, realistic? If so, consider using agile methods.
How large is the system that is being developed? Agile methods are most effective when the system can be developed with a small co-located team who can communicate informally. This may not be possible for large systems that require larger development teams so a plan-driven approach may have to be used.
Chapter 3 Agile software development
103

104. Technical, human, organizational issues
What type of system is being developed?
Plan-driven approaches may be required for systems that require a lot of analysis before implementation (e.g. real-time system with complex timing requirements).
What is the expected system lifetime?
Long-lifetime systems may require more design documentation to communicate the original intentions of the system developers to the support team.
What technologies are available to support system development?
Agile methods rely on good tools to keep track of an evolving design
How is the development team organized?
If the development team is distributed or if part of the development is being outsourced, then you may need to develop design documents to communicate across the development teams.
Chapter 3 Agile software development
104

105. Technical, human, organizational issues
Are there cultural or organizational issues that may affect the system development?
Traditional engineering organizations have a culture of plan-based development, as this is the norm in engineering.
How good are the designers and programmers in the development team?
It is sometimes argued that agile methods require higher skill levels than plan-based approaches in which programmers simply translate a detailed design into code
Is the system subject to external regulation?
If a system has to be approved by an external regulator (e.g. the FAA approve software that is critical to the operation of an aircraft) then you will probably be required to produce detailed documentation as part of the system safety case.
Chapter 3 Agile software development
105

106. Chapter 3 Agile software development
Extreme programming
Perhaps the best-known and most widely used agile method.
Extreme Programming (XP) takes an ‘extreme’ approach to iterative development.
New versions may be built several times per day;
Increments are delivered to customers every 2 weeks;
All tests must be run for every build and the build is only accepted if tests run successfully.
Chapter 3 Agile software development
106

107. XP and agile principles
Incremental development is supported through small, frequent system releases.
Customer involvement means full-time customer engagement with the team.
People not process through pair programming, collective ownership and a process that avoids long working hours.
Change supported through regular system releases.
Maintaining simplicity through constant refactoring of code.
Chapter 3 Agile software development
107

108. The extreme programming release cycle
Chapter 3 Agile software development
108

109. Extreme programming practices (a)
Principle or practice
Description
Incremental planning
Requirements are recorded on story cards and the stories to be included in a release are determined by the time available and their relative priority. The developers break these stories into development ‘Tasks’. See Figures 3.5 and 3.6.
Small releases
The minimal useful set of functionality that provides business value is developed first. Releases of the system are frequent and incrementally add functionality to the first release.
Simple design
Enough design is carried out to meet the current requirements and no more.
Test-first development
An automated unit test framework is used to write tests for a new piece of functionality before that functionality itself is implemented.
Refactoring
All developers are expected to refactor the code continuously as soon as possible code improvements are found. This keeps the code simple and maintainable.
Chapter 3 Agile software development
109

110. Extreme programming practices (b)
Pair programming
Developers work in pairs, checking each other’s work and providing the support to always do a good job.
Collective ownership
The pairs of developers work on all areas of the system, so that no islands of expertise develop and all the developers take responsibility for all of the code. Anyone can change anything.
Continuous integration
As soon as the work on a task is complete, it is integrated into the whole system. After any such integration, all the unit tests in the system must pass.
Sustainable pace
Large amounts of overtime are not considered acceptable as the net effect is often to reduce code quality and medium term productivity
On-site customer
A representative of the end-user of the system (the customer) should be available full time for the use of the XP team. In an extreme programming process, the customer is a member of the development team and is responsible for bringing system requirements to the team for implementation.
Chapter 3 Agile software development
110

111. Requirements scenarios
In XP, a customer or user is part of the XP team and is responsible for making decisions on requirements.
User requirements are expressed as scenarios or user stories.
These are written on cards and the development team break them down into implementation tasks. These tasks are the basis of schedule and cost estimates.
The customer chooses the stories for inclusion in the next release based on their priorities and the schedule estimates.
Chapter 3 Agile software development
111

112. A ‘prescribing medication’ story
Chapter 3 Agile software development
112

113. Examples of task cards for prescribing medication
Chapter 3 Agile software development
113

114. Chapter 3 Agile software development
XP and change
Conventional wisdom in software engineering is to design for change. It is worth spending time and effort anticipating changes as this reduces costs later in the life cycle.
XP, however, maintains that this is not worthwhile as changes cannot be reliably anticipated.
Rather, it proposes constant code improvement (refactoring) to make changes easier when they have to be implemented.
Chapter 3 Agile software development
114

115. Chapter 3 Agile software development
Refactoring
Programming team look for possible software improvements and make these improvements even where there is no immediate need for them.
This improves the understandability of the software and so reduces the need for documentation.
Changes are easier to make because the code is well-structured and clear.
However, some changes requires architecture refactoring and this is much more expensive.
Chapter 3 Agile software development
115

116. Examples of refactoring
Re-organization of a class hierarchy to remove duplicate code.
Tidying up and renaming attributes and methods to make them easier to understand.
The replacement of inline code with calls to methods that have been included in a program library.
Chapter 3 Agile software development
116

117. Chapter 3 Agile software development
Key points
Agile methods are incremental development methods that focus on rapid development, frequent releases of the software, reducing process overheads and producing high-quality code. They involve the customer directly in the development process.
The decision on whether to use an agile or a plan-driven approach to development should depend on the type of software being developed, the capabilities of the development team and the culture of the company developing the system.
Extreme programming is a well-known agile method that integrates a range of good programming practices such as frequent releases of the software, continuous software improvement and customer participation in the development team.
Chapter 3 Agile software development
117

118. Chapter 3 – Agile Software Development
Lecture 2
Chapter 3 Agile software development
118

119. Chapter 3 Agile software development
Testing in XP
Testing is central to XP and XP has developed an approach where the program is tested after every change has been made.
XP testing features:
Test-first development.
Incremental test development from scenarios.
User involvement in test development and validation.
Automated test harnesses are used to run all component tests each time that a new release is built.
Chapter 3 Agile software development
119

120. Test-first development
Writing tests before code clarifies the requirements to be implemented.
Tests are written as programs rather than data so that they can be executed automatically. The test includes a check that it has executed correctly.
Usually relies on a testing framework such as Junit.
All previous and new tests are run automatically when new functionality is added, thus checking that the new functionality has not introduced errors.
Chapter 3 Agile software development
120

121. Chapter 3 Agile software development
Customer involvement
The role of the customer in the testing process is to help develop acceptance tests for the stories that are to be implemented in the next release of the system.
The customer who is part of the team writes tests as development proceeds. All new code is therefore validated to ensure that it is what the customer needs.
However, people adopting the customer role have limited time available and so cannot work full-time with the development team. They may feel that providing the requirements was enough of a contribution and so may be reluctant to get involved in the testing process.
Chapter 3 Agile software development
121

122. Test case description for dose checking
Chapter 3 Agile software development
122

123. Chapter 3 Agile software development
Test automation
Test automation means that tests are written as executable components before the task is implemented
These testing components should be stand-alone, should simulate the submission of input to be tested and should check that the result meets the output specification. An automated test framework (e.g. Junit) is a system that makes it easy to write executable tests and submit a set of tests for execution.
As testing is automated, there is always a set of tests that can be quickly and easily executed
Whenever any functionality is added to the system, the tests can be run and problems that the new code has introduced can be caught immediately.
Chapter 3 Agile software development
123

124. XP testing difficulties
Programmers prefer programming to testing and sometimes they take short cuts when writing tests. For example, they may write incomplete tests that do not check for all possible exceptions that may occur.
Some tests can be very difficult to write incrementally. For example, in a complex user interface, it is often difficult to write unit tests for the code that implements the ‘display logic’ and workflow between screens.
It difficult to judge the completeness of a set of tests. Although you may have a lot of system tests, your test set may not provide complete coverage.
Chapter 3 Agile software development
124

125. Chapter 3 Agile software development
Pair programming
In XP, programmers work in pairs, sitting together to develop code.
This helps develop common ownership of code and spreads knowledge across the team.
It serves as an informal review process as each line of code is looked at by more than 1 person.
It encourages refactoring as the whole team can benefit from this.
Measurements suggest that development productivity with pair programming is similar to that of two people working independently.
Chapter 3 Agile software development
125

126. Chapter 3 Agile software development
Pair programming
In pair programming, programmers sit together at the same workstation to develop the software.
Pairs are created dynamically so that all team members work with each other during the development process.
The sharing of knowledge that happens during pair programming is very important as it reduces the overall risks to a project when team members leave.
Pair programming is not necessarily inefficient and there is evidence that a pair working together is more efficient than 2 programmers working separately.
Chapter 3 Agile software development
126

127. Advantages of pair programming
It supports the idea of collective ownership and responsibility for the system.
Individuals are not held responsible for problems with the code. Instead, the team has collective responsibility for resolving these problems.
It acts as an informal review process because each line of code is looked at by at least two people.
It helps support refactoring, which is a process of software improvement.
Where pair programming and collective ownership are used, others benefit immediately from the refactoring so they are likely to support the process.
Chapter 3 Agile software development
127

128. Agile project management
The principal responsibility of software project managers is to manage the project so that the software is delivered on time and within the planned budget for the project.
The standard approach to project management is plan-driven. Managers draw up a plan for the project showing what should be delivered, when it should be delivered and who will work on the development of the project deliverables.
Agile project management requires a different approach, which is adapted to incremental development and the particular strengths of agile methods.
Chapter 3 Agile software development
128

129. Chapter 3 Agile software development
Scrum
The Scrum approach is a general agile method but its focus is on managing iterative development rather than specific agile practices.
There are three phases in Scrum.
The initial phase is an outline planning phase where you establish the general objectives for the project and design the software architecture.
This is followed by a series of sprint cycles, where each cycle develops an increment of the system.
The project closure phase wraps up the project, completes required documentation such as system help frames and user manuals and assesses the lessons learned from the project.
Chapter 3 Agile software development
129

130. Chapter 3 Agile software development
The Scrum process
Chapter 3 Agile software development
130

131. Chapter 3 Agile software development
The Sprint cycle
Sprints are fixed length, normally 2–4 weeks. They correspond to the development of a release of the system in XP.
The starting point for planning is the product backlog, which is the list of work to be done on the project.
The selection phase involves all of the project team who work with the customer to select the features and functionality to be developed during the sprint.
Chapter 3 Agile software development
131

132. Chapter 3 Agile software development
The Sprint cycle
Once these are agreed, the team organize themselves to develop the software. During this stage the team is isolated from the customer and the organization, with all communications channelled through the so-called ‘Scrum master’.
The role of the Scrum master is to protect the development team from external distractions.
At the end of the sprint, the work done is reviewed and presented to stakeholders. The next sprint cycle then begins.
Chapter 3 Agile software development
132

133. Chapter 3 Agile software development
Teamwork in Scrum
The ‘Scrum master’ is a facilitator who arranges daily meetings, tracks the backlog of work to be done, records decisions, measures progress against the backlog and communicates with customers and management outside of the team.
The whole team attends short daily meetings where all team members share information, describe their progress since the last meeting, problems that have arisen and what is planned for the following day.
This means that everyone on the team knows what is going on and, if problems arise, can re-plan short-term work to cope with them.
Chapter 3 Agile software development
133

134. Chapter 3 Agile software development
Scrum benefits
The product is broken down into a set of manageable and understandable chunks.
Unstable requirements do not hold up progress.
The whole team have visibility of everything and consequently team communication is improved.
Customers see on-time delivery of increments and gain feedback on how the product works.
Trust between customers and developers is established and a positive culture is created in which everyone expects the project to succeed.
Chapter 3 Agile software development
134

135. Chapter 3 Agile software development
Scaling agile methods
Agile methods have proved to be successful for small and medium sized projects that can be developed by a small co- located team.
It is sometimes argued that the success of these methods comes because of improved communications which is possible when everyone is working together.
Scaling up agile methods involves changing these to cope with larger, longer projects where there are multiple development teams, perhaps working in different locations.
Chapter 3 Agile software development
135

136. Large systems development
Large systems are usually collections of separate, communicating systems, where separate teams develop each system. Frequently, these teams are working in different places, sometimes in different time zones.
Large systems are ‘brownfield systems’, that is they include and interact with a number of existing systems. Many of the system requirements are concerned with this interaction and so don’t really lend themselves to flexibility and incremental development.
Where several systems are integrated to create a system, a significant fraction of the development is concerned with system configuration rather than original code development.
Chapter 3 Agile software development
136

137. Large system development
Large systems and their development processes are often constrained by external rules and regulations limiting the way that they can be developed.
Large systems have a long procurement and development time. It is difficult to maintain coherent teams who know about the system over that period as, inevitably, people move on to other jobs and projects.
Large systems usually have a diverse set of stakeholders. It is practically impossible to involve all of these different stakeholders in the development process.
Chapter 3 Agile software development
137

138. Scaling out and scaling up
‘Scaling up’ is concerned with using agile methods for developing large software systems that cannot be developed by a small team.
‘Scaling out’ is concerned with how agile methods can be introduced across a large organization with many years of software development experience.
When scaling agile methods it is essential to maintain agile fundamentals
Flexible planning, frequent system releases, continuous integration, test- driven development and good team communications.
Chapter 3 Agile software development
138

139. Scaling up to large systems
For large systems development, it is not possible to focus only on the code of the system. You need to do more up-front design and system documentation
Cross-team communication mechanisms have to be designed and used. This should involve regular phone and video conferences between team members and frequent, short electronic meetings where teams update each other on progress.
Continuous integration, where the whole system is built every time any developer checks in a change, is practically impossible. However, it is essential to maintain frequent system builds and regular releases of the system.
Chapter 3 Agile software development
139

140. Scaling out to large companies
Project managers who do not have experience of agile methods may be reluctant to accept the risk of a new approach.
Large organizations often have quality procedures and standards that all projects are expected to follow and, because of their bureaucratic nature, these are likely to be incompatible with agile methods.
Agile methods seem to work best when team members have a relatively high skill level. However, within large organizations, there are likely to be a wide range of skills and abilities.
There may be cultural resistance to agile methods, especially in those organizations that have a long history of using conventional systems engineering processes.
Chapter 3 Agile software development
140

141. Chapter 3 Agile software development
Key points
A particular strength of extreme programming is the development of automated tests before a program feature is created. All tests must successfully execute when an increment is integrated into a system.
The Scrum method is an agile method that provides a project management framework. It is centred round a set of sprints, which are fixed time periods when a system increment is developed.
Scaling agile methods for large systems is difficult. Large systems need up-front design and some documentation.
Chapter 3 Agile software development
141