Module 3 AGILE DEVELOPMENT:

1 Explain principles of Agility. June 2024

The Agile Alliance defines 12 agility principles for those who want to achieve agility:
1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable
software.
2. Welcome changing requirements, even late in development. Agile processes harness change for
the customer’s competitive advantage.
3. Deliver working software frequently, from a couple of weeks to a couple of months, with a
preference to the shorter timescale.
4. Business people and developers must work together daily throughout the project.
5. Build projects around motivated individuals. Give them the environment and support they need,
and trust them to get the job done.
6. The most efficient and effective method of conveying information to and within a development
team is face-to-face conversation.
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development. The sponsors, developers, and users should be
able to maintain a constant pace indefinitely.
9. Continuous attention to technical excellence and good design enhances agility.
10. Simplicity—the art of maximizing the amount of work not done—is essential.
11. The best architectures, requirements, and designs emerge from self–organizing teams.
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its
behavior accordingly.

2 Explain the process of Extreme Programming. June 2024

Extreme Programming (XP), the most widely used approach to agile software development. XP is a
set of engineering practices. Developers have to go beyond their capabilities while performing these
practices. That’s where the "extreme" in the framework’s title comes from.

Software Engineering & Project Management

 Extreme Programming
Process
The XP framework normally involves 5 phases or stages of the development process
that iterate continuously:

Planning, the first stage, is when the customer meets the development team and presents
the requirements in the form of user stories to describe the desired result. The team then estimates the
stories and creates a release plan broken down into iterations needed to cover the required
functionality part after part. If one or more of the stories can’t be estimated, so-called spikes can be
introduced which means that further research is needed.

Designing is actually a part of the planning process, but can be set apart to emphasize its
importance. It’s related to one of the main XP values that we’ll discuss below -- simplicity. A good
design brings logic and structure to the system and allows to avoid unnecessary complexities and
redundancies. XP encourages the use of CRC cards (Chapter 7) as an effective mechanism for
thinking about the software in an object-oriented context

Coding is the phase during which the actual code is created by implementing specific XP practices
such as coding standards, pair programming, continuous integration, and collective code ownership
(the entire list is described below).

Software Engineering & Project Management

 Testing is the core of extreme programming. It is the regular activity that involves both unit tests
(automated testing to determine if the developed feature works properly) and acceptance tests
(customer testing to verify that the overall system is created according to the initial requirements).
I have already noted that the creation of unit tests before coding commences is a key element
of the XP approach. The unit tests that are created should be implemented using a framework that
enables them to be automated. This encourages a regression testing strategy whenever code is
modified

3 Explain Scrum process Model. June 2024

Scrum is an agile software development method. Scrum principles are consistent with the
agile manifesto and are used to guide development activities within a process that incorporates the
following framework activities: requirements, analysis, design, evolution, and delivery. Within each
framework activity, work tasks occur within a process pattern called a sprint.

Scrum Teams follow five core values: Commitment, Courage, Focus, Openness, Respect

Scrum emphasizes the use of a set of software process patterns [Noy02] that have proven effective
for projects with tight timelines, changing requirements, and business criticality. Each of these
process patterns defines a set of development actions:

Backlog—a prioritized list of project requirements or features that provide business value for the
customer. Items can be added to the backlog at any time (this is how changes are introduced). The
product manager assesses the backlog and updates priorities as required.

Sprints—consist of work units that are required to achieve a requirement defined in the backlog that
must be fit into a predefined time-box. Changes (e.g., backlog work items) are not introduced during
the sprint. Hence, the sprint allows team members to work in a short-term, but stable environment.

Scrum meetings—are short (typically 15 minutes) meetings held daily by the Scrum team. Three key
questions are asked and answered by all team members
• What did you do since the last team meeting?
• What obstacles are you encountering?
• What do you plan to accomplish by the next team meeting?

Scrum artifacts :Product Backlog , Sprint Backlog, Increment

A Scrum Team needs three specific roles: a Product Owner, Scrum leader, and development team.

A team leader, called a Scrum master, leads the meeting and assesses the responses from each
person. The Scrum meeting helps the team to uncover potential problems as early as possible. Also,
these daily meetings lead to “knowledge socialization” [Bee99] and thereby promote a self-
organizing team structure.

Demos—deliver the software increment to the customer so that functionality that has been
implemented can be demonstrated and evaluated by the customer. It is important to note that the
demo may not contain all planned functionality, but rather those functions that can be delivered
within the time-box that was established.

Software Engineering & Project Management

4 Explain Feature Driven Development (FDD)
June 2024

FDD adopts a philosophy that

(1) emphasizes collaboration among people
(2) manages problem and project complexity
(3) communication of technical detail using verbal, graphical, and text-based means.

• FDD emphasizes software quality assurance activities by encouraging an incremental

development strategy, the use of design and code inspections, the application of software
quality assurance audits

In the context of FDD, a feature “is a client-valued function that can be implemented in two weeks or
less” [Coa99]. The emphasis on the definition of features provides the following benefits:

• Because features are small blocks of deliverable functionality, users can describe them more easily;
understand how they relate to one another more readily; and better review them for ambiguity, error,
or omissions.
• Features can be organized into a hierarchical business-related grouping.
• Since a feature is the FDD deliverable software increment, the team develops operational features
every two weeks.
• Because features are small, their design and code representations are easier to inspect effectively.

Software Engineering & Project Management

• Project planning, scheduling, and tracking are driven by the feature hierarchy, rather than an
arbitrarily adopted software engineering task set.

The FDD approach defines five “collaborating” [Coa99] framework activities (in FDD these are
called “processes”) as shown in Figure.

To accomplish software increments are properly schedule FDD defines six milestones during the
design and implementation of a feature: “design walkthrough, design, design inspection, code, code
inspection, promote to build”

5 Explain Agility and the cost of change.

The conventional wisdom in software development is that the cost of change increases
nonlinearly as a project progresses. It is relatively easy to accommodate a change when a
software team is gathering requirements.

if we fast-forward a number of months? The team is in the middle of validation testing

and an important stakeholder is requesting a major functional change. The change requires a
modification to the architectural design of the software, the design and construction of three
new components, modifications to another five components, the design of new tests, and so
on. Costs escalate quickly,

a well-designed agile process “flattens” the cost of change curve (Figure 3.1, shaded,
solid curve), allowing a software team to accommodate changes late in a software
project without dramatic cost and time impact

Software Engineering & Project Management

6 List Other Agile Process Models

the most widely used of all agile process models is Extreme Programming (XP). But many
other agile process models have been proposed and are in use across the industry. Among the most
common are:
• Adaptive Software Development (ASD)
• Scrum
• Dynamic Systems Development Method (DSDM)
• Crystal
• Feature Drive Development (FDD)
• Lean Software Development (LSD)
• Agile Modeling (AM)
• Agile Unified Process (AUP)

7 Explain Lean Software Development (LSD)

Lean Software Development (LSD) has adapted the principles of lean manufacturing to the
world of software engineering. The lean principles that inspire the LSD process can be summarized
as eliminate waste, build quality in, create knowledge, defer commitment, deliver fast, respect
people, and optimize the whole.

(1) adding no extraneous features or functions,

(2) assessing the cost and schedule impact of any newly requested requirement

Software Engineering & Project Management

(3) removing any unnecessary process steps,
(4) establishing mechanisms to improve the way team members find information
(5) ensuring the testing finds as many errors as possible
(6) reducing the time required to request and get a decision that affects the software or the process
that is applied to create it, and
(7) streamlining the manner in which information is transmitted to all stakeholders involved in the
process.

8 Explain A tool set for Agile process.

Some proponents of the agile philosophy argue that automated software tools should be viewed as a
minor supplement to the team’s activities, and not at all pivotal to the success of the team.
“agile teams stress using tools that permit the rapid flow of understanding. Some of those
tools are social, starting even at the hiring stage. Some tools are technological, helping distributed
teams simulate being physically present.
Because acquiring the right people (hiring), team collaboration, stakeholder communication,
and indirect management are key elements in virtually all agile process models. “tools” that address
these issues are critical success factors for agility.
Collaborative and communication “tools” are generally low tech and incorporate any
mechanism (“physical proximity, whiteboards, poster sheets, index cards, and sticky notes”). Active
communication is achieved via the team dynamics, while passive communication is achieved by
“information radiators”
Project management tools deemphasize the Gantt chart and replace it with earned value charts
or “graphs of tests created versus passed. other agile tools are used to optimize the environment in
which the agile team works (e.g., more efficient meeting areas), improve the team culture by
nurturing social interactions (e.g., collocated teams), physical devices (e.g., electronic whiteboards),
and process enhancement (e.g., pair programming)

Module 3.2 Principles that guide practice

1 Explain the importance of Software Engineering Knowledge
Many software practitioners think of software engineering knowledge almost exclusively as
knowledge of specific technologies: Java, Perl, html, C__, Linux, Windows NT, and so on.

You often hear people say that software development knowledge has a 3-year half-life: half of what
you need to know today will be obsolete within 3 years. In the domain of technology-related
knowledge, that’s probably about right. But there is another kind of software development
knowledge—a kind that I think of as “software engineering principles”—that does not have a three-
year half-life. These software engineering principles are likely to serve a professional programmer
throughout his or her career.

Software Engineering & Project Management

2 Explain the Core principles
Software engineering is guided by a collection of core principles that help
in the application of a meaningful software process and the execution of
effective software engineering methods.

core principles establish a collection of values and rules that serve as a

guide as you analyze a problem, design a solution, implement and test the
solution, and ultimately deploy the software in the user community .
Principles That Guide Process
The following set of core principles can be applied to every software process.
1. Be agile.
2. Focus on quality at every step.
3. Be ready to adapt
4. Build an effective team
5. Establish mechanisms for communication and coordination
6. Manage change
7. Assess risk
8. Create work products that provide value for others
Principles That Guide Practice
Software engineering practice has a single overriding goal—to deliver on-time, high quality,
operational software that contains functions and features that meet the needs of all stakeholders. To
achieve this goal, you should adopt a set of core principles that guide your technical work.
1. Divide and conquer
2. Understand the use of abstraction
3. Strive for consistency
4. Focus on the transfer of information
5. Build software that exhibits effective modularity
6. Look for patterns
7. When possible, represent the problem and its solution from a number of different
perspectives
8. Remember that someone will maintain the software

3 Explain the Principles that guide each framework activity

principles that have a strong bearing on the success of each generic framework activity defined as
part of the software process.

Communication Principles: Before customer requirements can be analyzed, modeled, or specified

they must

Software Engineering & Project Management

be gathered through the communication activity. You respond to the customer’s request for help.
Communication has begun. But the road from communication to understanding is often full of
potholes.

1. Listen
2. Prepare before you communicate
3. Someone should facilitate the activity
4. Face-to-face communication is best
5. Take notes and document decisions
6. Strive for collaboration
7. Stay focused; modularize your discussion
8. If something is unclear, draw a picture
9. Once you agree to something, move on
10. Negotiation is not a contest or a game. It works best when both parties win

Planning Principles: The planning activity encompasses a set of management and technical practices
that enable the software team to define a road map as it travels toward its strategic goal and tactical
objectives. Over planning is time consuming and fruitless , but under planning is a recipe for chaos.
Regardless of the rigor with which planning is conducted, the following principles always apply:

1. Understand the scope of the project

2. Involve stakeholders in the planning activity
3. Recognize that planning is iterative
4. Estimate based on what you know
5. Consider risk as you define the plan
6. Be realistic
7. Adjust granularity as you define the plan
8. Define how you intend to ensure quality
9. Describe how you intend to accommodate change
10. Track the plan frequently and make adjustments as required

Modeling Principles: We create models to gain a better understanding of the actual entity to be built.
When the entity is a physical thing we can build a model that is identical in form and shape but
smaller in scale. when the entity to be built is software, our model must take a different form. It must
be capable of representing the information that software transforms, the architecture and functions
that enable the transformation to occur, the features that users desire, and the behavior of the system
as the transformation is taking place.

Software Engineering & Project Management

 1. The primary goal of the software team is to build software, not create models
2. Travel light—don’t create more models than you need
3. Strive to produce the simplest model that will describe the problem or the software
4. Build models in a way that makes them amenable to change
5. Be able to state an explicit purpose for each model that is created
6. Adapt the models you develop to the system at hand
7. Try to build useful models, but forget about building perfect models
8. Don’t become dogmatic about the syntax of the model
9. If your instincts tell you a model isn’t right even though it seems okay on paper, you
probably have reason to be concerned
10. Get feedback as soon as you can

Construction Principles: The construction activity encompasses a set of coding and testing tasks that
lead to operational software that is ready for delivery to the customer or end user.

Coding Principles. The principles that guide the coding task are closely aligned with
programming style, programming languages, and programming methods. However, there are a
number of fundamental principles that can be stated:

Preparation principles: Before you write one line of code, be sure you
• Understand of the problem you’re trying to solve.
• Understand basic design principles and concepts.
• Pick a programming language that meets the needs of the software to be built and the
environment in which it will operate.
• Select a programming environment that provides tools that will make your work easier.
• Create a set of unit tests that will be applied once the component you code is completed.

Programming principles: As you begin writing code, be sure you

 Constrain your algorithms by following structured programming practice.
• Consider the use of pair programming.
• Select data structures that will meet the needs of the design.
 Understand the software architecture and create interfaces that are consistent with it.
• Keep conditional logic as simple as possible.
• Create nested loops in a way that makes them easily testable.
• Select meaningful variable names and follow other local coding standards.
 Write code that is self-documenting.

Validation Principles: After you’ve completed your first coding pass, be sure you
 Conduct a code walkthrough when appropriate.
 Perform unit tests and correct errors you’ve uncovered.
 Refactor the code.

Software Engineering & Project Management

 Testing Principles.
• Testing is a process of executing a program with the intent of finding an error.
• A good test case is one that has a high probability of finding an as-yet undiscovered error.
• A successful test is one that uncovers an as-yet-undiscovered error.

Deployment Principles: deployment activity encompasses three actions: delivery, support, and
feedback. The delivery of a software increment represents an important milestone for any software
project. A number of key principles should be followed as the team prepares
to deliver an increment:

1. Customer expectations for the software must be managed

2. A complete delivery package should be assembled and tested.
3. A support regime must be established before the software is delivered
4. Appropriate instructional materials must be provided to end users
5. Buggy software should be fixed first, delivered later

4 Explain Construction Principles

5 Explain Planning Principles
6 Explain Modeling Principles
7 Explain Deployment Principles

Software Engineering & Project Management