Lecture2 - SW Processes and Agile

Software Processes and Agile Development
Topics covered
 Software Process
 Software process models
 Process activities
 Coping with change
 Process improvement
 Agile
 Agile methods
 Agile development techniques
 Agile project management
 Scaling agile methods
05/12/2024 Chapter 2 Software Processes 2

The software process
 A structured set of activities required to develop a software system.
 Many different software processes but all involve:
 Specification – defining what the system should do;
 Design and implementation – defining the organization of the system and
implementing the system;
 Validation – checking that it does what the customer wants;
 Evolution – changing the system in response to changing customer needs.
 A software process model is an abstract representation of a process. It
presents a description of a process from some particular perspective.

Software process descriptions
 Process descriptions may also include:
 Products,
• are the outcomes of a process activity;
 Roles
• Reflects the responsibilities of the people involved in the process;
 Pre- and post-conditions,
• Are statements that are true before and after a process activity has been enacted or a
product produced.
• Example: cash withdrawal use cse

Plan-driven and agile processes
 Plan-driven processes
 all of the process activities are planned in advance and
 Progress is measured against this plan.
 In agile processes,
 planning is incremental and
 it is easier to change the process to reflect changing customer requirements.
 In practice,
 most practical processes include elements of both plan-driven and agile approaches.
There are no right or wrong software processes.

Software process models

Software process models
 The waterfall model
 Plan-driven model. Separate and distinct phases of specification and development.
 Incremental development
 Specification, development and validation are interleaved. May be plan-driven or
agile.
 Integration and configuration
 The system is assembled from existing configurable components. May be plan-driven
or agile.
 In practice, most large systems are developed using a process that
incorporates elements from all of these models.

The waterfall model

1. Waterfall model problems
 Inflexible partitioning of the project into distinct stages makes it difficult to respond
to changing customer requirements.
 Therefore, this model is only appropriate when the requirements are well-understood and changes
will be fairly limited during the design process.
 Few business systems have stable requirements.
 This model is mostly used for large systems engineering projects where a system is
developed at several sites.
 In those circumstances, the plan-driven nature of the waterfall model helps coordinate the work.
 The main drawback:
 Difficult to accommodate change after the process is underway. In principle, a phase has to be
completed before moving on to the next phase.

2. Incremental development

Incremental development benefits
 The cost of accommodating changing customer requirements is reduced.
 The amount of analysis and documentation that has to be redone is much less than is
required with the waterfall model.
 It is easier to get customer feedback on the development work that has
been done.
 Customers can comment on demonstrations of the software and see how much has
been implemented.
 More rapid delivery and deployment of useful software to the customer is
possible.
 Customers are able to use and gain value from the software earlier than is possible
with a waterfall process.

Incremental development problems
 The process is not visible.
 Managers need regular deliverables to measure progress.
 If systems are developed quickly, it is not cost-effective to produce documents that reflect
every version of the system.
 System structure tends to degrade as new increments are added.
 Unless time and money is spent on refactoring to improve the software, regular change
tends to corrupt its structure.
 Incorporating further software changes becomes increasingly difficult and costly.

3. Integration and configuration
 Based on software reuse where systems are integrated from existing
components or application systems (sometimes called COTS -
Commercial-off-the-shelf) systems).
 Reused elements may be configured to adapt their behaviour and
functionality to a user’s requirements
 Reuse is now the standard approach for building many types of business
system
 Reuse covered in more depth in Chapter 15.

Types of reusable software
 Stand-alone application systems (sometimes called COTS) that are
configured for use in a particular environment.
 Collections of objects that are developed as a package to be integrated with
a component framework such as .NET or J2EE.
 Web services that are developed according to service standards and which
are available for remote invocation.

Reuse-oriented software engineering
 Key process stages

 Requirements specification
 Software discovery and evaluation
 Requirements refinement
 Application system configuration
 Component adaptation and integration

Advantages and disadvantages
 Reduced costs and risks as less software is developed from scratch
 Faster delivery and deployment of the system
 But requirements compromises are inevitable so the system may not meet
the real needs of users
 Loss of control over the evolution of reused system elements

Coping with change

Coping with change
 Change is inevitable in all large software projects.
 Business changes lead to new and changed system requirements
 New technologies open up new possibilities for improving implementations
 Changing platforms requires application changes
 Change leads to rework so the costs of change include both rework (e.g.
re-analyzing requirements) as well as the costs of implementing new
functionality

Reducing the costs of rework
 Change anticipation, where the software process includes activities that
can anticipate possible changes before significant rework is required.
 For example, a prototype system may be developed to show some key features of the
system to customers.
 Change tolerance, where the process is designed so that changes can be
accommodated at relatively low cost.
 This normally involves some form of incremental development. Proposed changes
may be implemented in increments that have not yet been developed. If this is
impossible, then only a single increment (a small part of the system) may have be
altered to incorporate the change.

Software prototyping
 A prototype is an initial version of a system used to demonstrate concepts
and try out design options.
 A prototype can be used in:
 The requirements engineering process to help with requirements elicitation and
validation;
 In design processes to explore options and develop a UI design;

Benefits of prototyping
 Improved system usability.
 A closer match to users’ real needs.
 Improved design quality.
 Improved maintainability.
 Reduced development effort.

The process of prototype development

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

Throw-away prototypes
 Prototypes should be discarded after development as they are not a good
basis for a production system:
 It may be impossible to tune the system to meet non-functional requirements;
 Prototypes are normally undocumented;
 The prototype structure is usually degraded through rapid change;
 The prototype probably will not meet normal organizational quality standards.

Incremental delivery
 Rather than deliver the system as a single delivery,
 the development and delivery are broken down into increments with each increment delivering part of the
required functionality.
 User requirements are prioritized 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.

Incremental development and delivery
 Incremental development
 Develop the system in increments and evaluate each increment before proceeding to
the development of the next increment;
 Normal approach used in agile methods;
 Evaluation is done by user/customer proxy.
 Incremental delivery
 Deploy an increment for use by end-users;
 More realistic evaluation about practical use of software;
 Difficult to implement for replacement systems as increments have less functionality
than the system being replaced.

Incremental delivery

Incremental delivery 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.

Incremental delivery problems
 Most systems require a set of basic facilities that are used by different
parts of the system.
 As requirements are not defined in detail until an increment is to be implemented, it
can be hard to identify common facilities that are needed by all increments.
 The essence of iterative processes is that the specification is developed in
conjunction with the software.
 However, this conflicts with the procurement model of many organizations, where the
complete system specification is part of the system development contract.

Process improvement

Process improvement
 Many software companies have turned to software process improvement as
a way of enhancing the quality of their software, reducing costs or
accelerating their development processes.
 Process improvement means understanding existing processes and
changing these processes to increase product quality and/or reduce costs
and development time.

Approaches to improvement
 The process maturity approach, which focuses on improving process and
project management and introducing good software engineering practice.
 The level of process maturity reflects the extent to which good technical and
management practice has been adopted in organizational software development
processes.
 The agile approach, which focuses on iterative development and the
reduction of overheads in the software process.
 The primary characteristics of agile methods are rapid delivery of functionality and
responsiveness to changing customer requirements.

The process improvement cycle

Chapter 3 – Agile Software Development
Topics covered
 Agile methods
 Agile development techniques
 Agile project management
 Scaling agile methods

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.
 Plan-driven development is essential for some types of system but does not
meet these business needs.
 Agile development methods emerged in the late 1990s whose aim was to
radically reduce the delivery time for working software systems

Agile development
 Program specification, design and implementation are inter-leaved
 The system is developed as a series of versions or increments with
stakeholders involved in version specification and evaluation
 Frequent delivery of new versions for evaluation
 Extensive tool support (e.g. automated testing tools) used to support
development.
 Minimal documentation – focus on working code

Plan-driven and agile 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.

The principles of agile methods
Principle 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.

Agile development techniques

Extreme programming
 A very influential agile method, developed in the late 1990s, that
introduced a range of agile development techniques.
 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.

The extreme programming release cycle

Extreme programming practices (a)
Principle or practice Description
Requirements are recorded on story cards and the stories to be included in a

Incremental planning release are determined by the time available and their relative priority. The
developers break these stories into development ‘Tasks’.
The minimal useful set of functionality that provides business value is developed
Small releases 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.
An automated unit test framework is used to write tests for a new piece of
Test-first development
functionality before that functionality itself is implemented.
All developers are expected to refactor the code continuously as soon as possible
Refactoring
code improvements are found. This keeps the code simple and maintainable.

Extreme programming practices (b)
Developers work in pairs, checking each other’s work and providing the
Pair programming
support to always do a good job.
The pairs of developers work on all areas of the system, so that no islands of
Collective ownership expertise develop and all the developers take responsibility for all of the code.
Anyone can change anything.
Continuous As soon as the work on a task is complete, it is integrated into the whole
integration system. After any such integration, all the unit tests in the system must pass.
Large amounts of overtime are not considered acceptable as the net effect is
Sustainable pace
often to reduce code quality and medium term productivity
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
On-site customer
process, the customer is a member of the development team and is
responsible for bringing system requirements to the team for implementation.

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.

Influential XP practices
 Extreme programming has a technical focus and is not easy to integrate
with management practice in most organizations.
 Consequently, while agile development uses practices from XP, the method
as originally defined is not widely used.
 Key practices
 User stories for specification
 Refactoring
 Test-first development
 Pair programming

User stories for requirements
 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 user stories or scenarios.
 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.

A ‘prescribing medication’ story

Examples of task cards for prescribing
medication

Refactoring
 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.

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.

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.

Test-first development
 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.

Test-driven 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.

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.

Test case description for dose checking

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.

Problems with test-first development
 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.

Pair programming
 Pair programming involves programmers working in pairs, developing
code together.
 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 improving
the system code.

Pair programming
 In pair programming, programmers sit together at the same computer 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 some evidence
that suggests that a pair working together is more efficient than 2
programmers working separately.

Agile project management

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 practices used in agile methods.

Scrum
 Scrum is an agile method that focuses 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.


Scrum terminology (a)
Scrum term Definition
Development team A self-organizing group of software developers, which should be no more than 7
people. They are responsible for developing the software and other essential project
documents.
Potentially shippable The software increment that is delivered from a sprint. The idea is that this should
product increment be ‘potentially shippable’ which means that it is in a finished state and no further
work, such as testing, is needed to incorporate it into the final product. In practice,
this is not always achievable.
Product backlog This is a list of ‘to do’ items which the Scrum team must tackle. They may be feature
definitions for the software, software requirements, user stories or descriptions of
supplementary tasks that are needed, such as architecture definition or user
documentation.
Product owner An individual (or possibly a small group) whose job is to identify product features or
requirements, prioritize these for development and continuously review the product
backlog to ensure that the project continues to meet critical business needs. The
Product Owner can be a customer but might also be a product manager in a
software company or other stakeholder representative.
Scrum terminology (b)
Scrum term Definition
Scrum A daily meeting of the Scrum team that reviews progress and prioritizes work to be
done that day. Ideally, this should be a short face-to-face meeting that includes the
whole team.
ScrumMaster The ScrumMaster is responsible for ensuring that the Scrum process is followed
and guides the team in the effective use of Scrum.
He or she is responsible for interfacing with the rest of the company and for
ensuring that the Scrum team is not diverted by outside interference. The Scrum
developers are adamant that the ScrumMaster should not be thought of as a project
manager. Others, however, may not always find it easy to see the difference.
Sprint A development iteration. Sprints are usually 2-4 weeks long.

Velocity An estimate of how much product backlog effort that a team can cover in a single
sprint. Understanding a team’s velocity helps them estimate what can be covered
in a sprint and provides a basis for measuring improving performance.

Scrum sprint cycle

The Scrum sprint cycle
 Sprints are fixed length, normally 2–4 weeks.
 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 from the product backlog
to be developed during the sprint.

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.

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 (Scrums) 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.

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.

Distributed Scrum

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.

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 importaant to maintain agile
fundamentals:
 Flexible planning, frequent system releases, continuous integration, test-driven
development and good team communications.

Practical problems with agile methods
 The informality of agile development is incompatible with the legal
approach to contract definition that is commonly used in large companies.
 Agile methods are most appropriate for new software development rather
than software maintenance. Yet the majority of software costs in large
companies come from maintaining their existing software systems.
 Agile methods are designed for small co-located teams yet much software
development now involves worldwide distributed teams.

System issues
 How large is the system being developed?
 Agile methods are most effective a relatively small co-located team who can
communicate informally.
 What type of system is being developed?
 Systems that require a lot of analysis before implementation need a fairly detailed
design to carry out this analysis.
 What is the expected system lifetime?
 Long-lifetime systems require documentation to communicate the intentions of the
system developers to the support team.
 Is the system subject to external regulation?
 If a system is regulated you will probably be required to produce detailed
documentation as part of the system safety case.

People and teams
 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.
 How is the development team organized?
 Design documents may be required if the team is dsitributed.
 What support technologies are available?
 IDE support for visualisation and program analysis is essential if design
documentation is not available.

Scaling up to large systems
 A completely incremental approach to requirements engineering is impossible.
 There cannot be a single product owner or customer representative.
 For large systems development, it is not possible to focus only on the code of the
system.
 Cross-team communication mechanisms have to be designed and used.
 Continuous integration is practically impossible. However, it is essential to
maintain frequent system builds and regular releases of the system.

Multi-team Scrum
 Role replication
 Each team has a Product Owner for their work component and ScrumMaster.
 Product architects
 Each team chooses a product architect and these architects collaborate to design and
evolve the overall system architecture.
 Release alignment
 The dates of product releases from each team are aligned so that a demonstrable and
complete system is produced.
 Scrum of Scrums
 There is a daily Scrum of Scrums where representatives from each team meet to
discuss progressand plan work to be done.

Lecture2 - SW Processes and Agile

Uploaded by

Copyright:

Available Formats

Lecture2 - SW Processes and Agile

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lecture2 - SW Processes and Agile

Uploaded by

Copyright:

Available Formats

Software Processes and Agile Development

05/12/2024 Chapter 2 Software Processes 2

05/12/2024 Chapter 2 Software Processes 3

05/12/2024 Chapter 2 Software Processes 4

05/12/2024 Chapter 2 Software Processes 5

05/12/2024 Chapter 2 Software Processes 6

05/12/2024 Chapter 2 Software Processes 7

05/12/2024 Chapter 2 Software Processes 8

05/12/2024 Chapter 2 Software Processes 9

05/12/2024 Chapter 2 Software Processes 10

05/12/2024 Chapter 2 Software Processes 11

05/12/2024 Chapter 2 Software Processes 12

05/12/2024 Chapter 2 Software Processes 13

05/12/2024 Chapter 2 Software Processes 14

 Key process stages

05/12/2024 Chapter 2 Software Processes 15

05/12/2024 Chapter 2 Software Processes 16

05/12/2024 Chapter 2 Software Processes 17

05/12/2024 Chapter 2 Software Processes 18

05/12/2024 Chapter 2 Software Processes 19

05/12/2024 Chapter 2 Software Processes 20

05/12/2024 Chapter 2 Software Processes 21

05/12/2024 Chapter 2 Software Processes 22

05/12/2024 Chapter 2 Software Processes 23

05/12/2024 Chapter 2 Software Processes 24

05/12/2024 Chapter 2 Software Processes 25

05/12/2024 Chapter 2 Software Processes 26

05/12/2024 Chapter 2 Software Processes 27

05/12/2024 Chapter 2 Software Processes 28

05/12/2024 Chapter 2 Software Processes 29

05/12/2024 Chapter 2 Software Processes 30

05/12/2024 Chapter 2 Software Processes 31

05/12/2024 Chapter 2 Software Processes 32

05/12/2024 Chapter 2 Software Processes 33

05/12/2024 Chapter 2 Software Processes 35

05/12/2024 Chapter 2 Software Processes 36

05/12/2024 Chapter 2 Software Processes 37

05/12/2024 Chapter 2 Software Processes 38

05/12/2024 Chapter 2 Software Processes 39

05/12/2024 Chapter 2 Software Processes 40

05/12/2024 Chapter 2 Software Processes 41

05/12/2024 Chapter 2 Software Processes 42

05/12/2024 Chapter 2 Software Processes 43

Requirements are recorded on story cards and the stories to be included in a

05/12/2024 Chapter 2 Software Processes 44

A representative of the end-user of the system (the customer) should be

05/12/2024 Chapter 2 Software Processes 45

05/12/2024 Chapter 2 Software Processes 46

05/12/2024 Chapter 2 Software Processes 47

05/12/2024 Chapter 2 Software Processes 48

05/12/2024 Chapter 2 Software Processes 49

05/12/2024 Chapter 2 Software Processes 50

05/12/2024 Chapter 2 Software Processes 51

05/12/2024 Chapter 2 Software Processes 52

05/12/2024 Chapter 2 Software Processes 53

05/12/2024 Chapter 2 Software Processes 54

05/12/2024 Chapter 2 Software Processes 55

05/12/2024 Chapter 2 Software Processes 56

05/12/2024 Chapter 2 Software Processes 57