Software Engineering

Sobia Iftikhar Week 03

Sobia.Iftikhar@nu.edu.pk
Content
• Agile methods
• Agile development techniques
• Agile project management
• Scaling agile methods

https://www.knowledgehut.com/blog/agile/agile-project-management-vs-traditional-project-management
https://www.youtube.com/watch?v=5RocT_OdQcA
Agile?

In this fast-moving world, project management has become one of the most important pillars that are helping
businesses run without any glitch in their processes.

Both small- and large-scale organizations around the world depend on project management systems to deliver
their products/services successfully.

Whether it is team workflow management or timing, these tools help to ensure that the processes flow in a
hassle-free manner while achieving the desired goals.

Despite the presence of different project management approaches, Agile is considered as one of the most
practical and flexible software development mechanisms that exist today.

It is capable of executing a variety of tasks.

Agile methods
• Plan-driven approaches involve a significant overhead in
planning, designing, and documenting the system.
• More time is spent on how the system should be developed
than on program development and testing. As the system
requirements change, rework is essential
• Dissatisfaction with heavyweight approaches to software
engineering led to the development of agile methods in the
late 1990s.
Agile method focus on;

Are intended to deliver Focus on the code

working software rather than the
quickly and evolve this design
quickly to meet
changing requirements.

Are based on an iterative

approach to software
development
Aim
• 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.
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

The principles of agile methods
1. 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.
The principles of agile methods
1. Incremental delivery
The software is developed in increments
with the customer specifying the
requirements to be included in each
increment.
.
The principles of agile methods
3. 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..

4. Embrace change

Expect the system requirements to change and so design the system to accommodate
these changes.

5. 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 methods have been particularly successful for two
kinds of system development.

• 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
Agile development techniques
1. Extreme Programming (Xp)
2. Scrum
Extreme Programming (Xp)
• Extreme Programming (XP) is an First agile software development framework that aims to
produce higher quality software.
• It is lightweight methodology for small to medium sized team developing software in the face of
rapidly changing requirements.
• Xp always Emphasis on technical aspects of software development.
• XP is a set of engineering practices.
The extreme programming release cycle
Extreme programming practices

Small releases:
Incremental planning: The minimal useful set of Simple design; Enough
Requirements are recorded on functionality that provides design is carried out to
story cards and the stories to business value is developed meet the current
be included in a release are first. Releases of the system requirements and no
determined by the time are frequent and incrementally
available and their relative more.
priority. The developers break add functionality to the first
these stories into development release.
Extreme programming practices

Refactoring
Test-first development Pair programming
All developers are
An automated unit test expected to refactor the Developers work in pairs,
framework is used to code continuously as checking each other’s
write tests for a new piece soon as possible code work and providing the
of functionality before improvements are found. support to always do a
that functionality itself is This keeps the code good job.
implemented. simple and maintainable.
 Extreme programming practices

On-site customer
Collective ownership Continuous integration A representative of the end-
Sustainable pace user of the system (the
The pairs of developers As soon as the work on a
work on all areas of the Large amounts of overtime customer) should be available
task is complete, it is are not considered full time for the use of the XP
system, so that no islands integrated into the whole acceptable as the net effect is team. In an extreme
of expertise develop and system. After any such programming process, the
all the developers take often to reduce code quality
responsibility for all of the
integration, all the unit and medium term customer is a member of the
tests in the system must productivity development team and is
code. Anyone can change responsible for bringing
anything. pass. system requirements to the
team for implementation.
Influential XP practices
• Key practices
• User stories for specification
• Refactoring
• Test-first development
• Pair programming
User-Story
User-Story
User-Story
User-Story
User-Story
A ‘prescribing medication’ story
Examples of task cards for prescribing medication
Refactoring
• A fundamental precept of traditional software engineering is that you should design for change.
• Extreme programming, however, has discarded this principle on the basis that designing for
change is often wasted effort.
• changes will always have to be made to the code being developed. To make these changes easier,
the developers of XP suggested that the code being developed should be constantly refactored.
Refactoring
• Refactoring improves the software structure and readability and so avoids the structural
deterioration that naturally occurs when software is changed.

• class PizzaDelivery:
• def getgrades(self):
• return 'A' if self.moretheneight() else B
• def ismorethaneight(self):
• return self.number > 8
• This could be refactored as:

• class PizzaDelivery:
• def getgrades(self):
• return self.number > 8 ? A : B
Test-first development
• XP testing features:
• 1. test-first development,
• 2. incremental test development from scenarios,
• 3. user involvement in the test development and validation,
• 4. the use of automated testing framework

https://www.youtube.com/watch?v=zFJdQYn9u_8
Test-first development
1. The developer accepts a unit of work and writes a set of tests that will prove that the code
actually functions correctly at a unit level.
2.They then run the tests. The tests should fail because the code to solve the business
problem embedded in the unit of work has not been written. If the tests pass, rewrite
them so that they fail (assuming someone else has not fixed the problem).
3.Write the code needed to solve the problem. Run the test suite again. If the tests pass you
are done.
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.
 Example
we will define a class password. For this
class, we will try to satisfy following
conditions.
• A condition for Password acceptance:
• The password should be between 5 to 10
characters.

Scenario 1: To run the test, we create class PasswordValidator

();
Example
• The following sequence of steps is
generally followed:
• Add a test
• Run all tests and see if the new one fails
• Write some code
• Run tests
• Refactor code
• Repeat
Example
Example
Test case description for dose checking
Example
Agile Earlier issues
 To Address this issue

• (Schwaber and Beedle

2001; Rubin 2013) to
provide a framework for
organizing agile projects
and, to some extent at
least, provide external
visibility of what is going
on.
Scrum
• Scrum is one of the agile methodologies /framework designed to guide teams in
the iterative and incremental delivery of a product. Often referred to as “an agile
project management framework
• We should first be clear on what Scrum is not.
• There is a common misconception that Agile is Scrum. While Scrum is indeed
agile, it is not the sole method of implementing agile principles.
• Scrum is simply one of many agile approaches to product development.
 Scrum Team
A self-organizing group of software developers, which should be no more than
seven people. They are responsible for developing the software and other
essential project documents.

The software increment that is delivered from a sprint. The idea is that this
should be “potentially shippable,” which means that it is in a finished state.

This is a list of “to do” items that 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

The Product Owner can be a customer but might also be a product manager in
a software company or other stakeholder representative

A daily meeting of the Scrum team that reviews progress and prioritizes work
to be done that day.

The ScrumMaster is responsible for ensuring that the Scrum process is

followed and guides the team in the effective use of Scrum

A development iteration. Sprints are usually 2 to 4 weeks long.

Velocity An estimate of how much product backlog effort 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.
 Velocity:
Velocity is a measure of the amount of work a
Team can tackle during a single Sprint and is the
key metric in Scrum. Velocity is calculated at the
end of the Sprint by totaling the Points for all
fully completed User Stories.
The Scrum process
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 daily interactions among Scrum teams may be coordinated using a Scrum board.
• This is a shared resource for the whole team, and anyone can change or move items on the board.
It means that any team member can, at a glance, see what others are doing and what work remains
to be done.
 Allows companies to take advantage of lower cost staff in other
countries, makes access to specialist skills possible, and allows for 24-
hour development, with work going on in different time zones.
Distributed Scrum
Distributed Scrum
Thankyou