MODULE- 3

AGILE DEVELOPMENT
WHAT IS AGILITY?
AGILITY AND THE COST OF CHANGES
 WHAT IS AN AGILE PROCESS?
• Any agile Software process is characterized in a manner that addresses a number of key
assumption about the majority of Software Project:
It is the difficult to predict in advance which software requirement will persist and
which will change.
For many types of software, design and construction are interleaved.

Analysis, design, construction and testing are not as predictable as we might like.
AGILITY PRINCIPLES:
The agile alliance defines 12 agility principles for those who want to achieve agility:

• Our highest priority is to satisfy the customer through early and continuous delivery

valuable software.

• Welcome changing requirements, even late in development. Agile Processes harness.

• Change for the customer’s competitive advantage.

• Deliver working software frequently, from a couple of weeks to a couple of months, with

a preference to the shorter timescale.

• Business people and developers must work together daily throughout the Project.
• Build Project around motivated individuals, Give them the environment and support they need and trust

them is face-to-face conversation.

• Working software is the primary measure of Progress.

• Agile Processes promote sustainable development. The sponsors, developers, and users should be able

to maintain a constant pace indefinitely.

• Continuous attention to technical excellence and good design enhances agility.

• The art of maximizing the amount of work not done-is essential.

• The best architectures, requirements and design emerge from self- Organizing Teams.

• At regular intervals, the team reflects on how to become more effective, then tunes and adjust its

behavior accordingly.
•
THE POLITICS OF AGILE DEVELOPMENT
• Human Factor
• Competence
• Common Focus
• Collaboration
• Decision Making Ability
• Fuzzy Problem Solving Ability
• Mutual Trust and Respect
• Self Organization: Implies 3 things
The agile team organizes itself for work to be done.
The team Organizes the process to best accommodate its local environment.
The team organizes the work schedule to best achieve delivery of software increment.
EXTREME PROGRAMMING(XP)
Extreme Programming(XP), the most widely used approach to agail software
development.
• Define set of FIVE Values.
1. Communication
2. Simplicity
3. Feedback
4. Courage
5. Respect
THE XP Process :
Four framework activities:
1. Planning
2. Design
3. Coding
4.Testing
Industrial XP(IXP):
IXP is an organic evolution of XP. It is imbued with XP’s minimalist, customer-centric, test-
driven spirit.
IXP incorporates six new practice that are designed to help ensure that an XP project works
successfully.
 Readiness assessment
 Project community
 Project chartering
 Test-driven management
 Retrospective
 Continuous learning

The XP Debate:
Issues that continue to trouble some critics of XP are:
 Requirement volatility
 Conflicting customer needs
 Requirements are expressed informally
 Lack of formal design
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:
 Adaptive Software Development(ASD)
 Scrum
 Dynamic System Development Method(DSDM)
 Crystal
 Feature Drive Development(FDD)
 Lean Software Development(LSD)
 Agile Modeling(AM)
 Agile Unified Process(AUP)
Adaptive Software Development(ASD):
Adaptive Software Development(ASD) as been proposed by Jim Highsmith as a technique
for building complex software.
SCRUM:
Scrum is an agile software development method that was proposed by Jeff Sutherland in 1990’s.
DYNAMIC SYSTEM DEVELOPMENT METHOD(DSDM):
• DSDM provides a framework for building and maintaining system which meet tight time
constraint through the use of incremental prototyping.
• The DSDM life cycle that defines three different iterative cycles, proceed by two
additional life cycle activities:
 Feasibility Study
 Business Study
 Functional Model Iteration
 Design and Build Iteration
 Implementation
CRYSTAL:
• Alistair Cockburn and Jim Highsmith created the Crystal family of agile method.
• Each core elements that are common to all roles, process patterns, work products and
practice that are unique to each.

LEAN SOFTWARE DEVELOPMENT(LSD):

LSD process can be summarized as eliminate waste, build quality in, create knowledge,
defer commitment, deliver fast, respect people, and optimize the whole.
For example, eliminate waste an agile software project can be:
(1) Adding no extraneous features or functions,
(2) Assessing the cost and schedule impact of any newly requested requirement,
(3) Removing any superfluous 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,
FEATURE DRIVEN DEVELOPMENT(FDD):
FDD adopts a philosophy that:
(1) emphasizes collaboration among people on an FDD team
(2)Manages problem and project complexity using feature-based decomposition
(3) communication of technical detail using verbal, graphical ,and text-based means

In the context of FDD, a feature “is a client-valued function that can be implemented in
two weeks or less”.
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
• Features can be organized in to a hierarchical business-related grouping.
• The team develops operational features every two weeks, Because features are
small.
• Project planning, scheduling and tracking are driven by the feature hierarchy.
Agile Unified Process(AUP):
The Agile Unified Process(AUP) adopts a “serial in the large” and “iterative in the small”
philosophy for building computer-based systems.
AUP provides a serial overlay that enables a team to visualize the overall process flow for
a software project.
Each AUP iteration addresses the following activities:
Modeling
Implementation
Testing
Deployment
Configuration and project management
Environment management
PRINCIPLES THAT GUIDE PRACTICE

Software Engineering Knowledge:

• Software engineering knowledge almost exclusively as knowledge of specific

technologies: Java, Perl, html, C++, Linux, Windows NT and soon.
• Knowledge of specific technology details is necessary toper form computer
programming.
• If someone assigns you to write a program in C++, you have to know something about
C++ to get your program to work.
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.
• At the process level,
• At the level of practice,
• General principles that span software engineering process and practice:
Principles That Guide Process:
• Principle 1: Be agile.
• Principle 2: Focus on quality at every step.
• Principle 3: Be ready to adapt.
• Principle 4: Build an effective team.
• Principle 5: Establish mechanisms for communication and coordination.
• Principle 6: Manage change
• Principle 7: Assess risk. Lots of things can go wrong as software is being developed.
It’s essential that you establish contingency plans.
• Principle 8: Create work products that provide value for others
 Principles That Guide Practice:

• Principle 1: Divide and conquer

• Principle 2: Understand the use of abstraction.
• Principle 3: Strive for consistency
• Principle 4: Focus on the transfer of information.
• Principle 5: Build software that exhibits effective modularity.
• Principle 6: Look for patterns.
• Principle 7: When possible, represent the problem and its solution from a number of
different perspectives.
• Principle 8: Remember that someone will maintain the software.
 PRINCIPLES THAT GUIDE EACH FRAMEWORK ACTIVITY:

Communication Principles:

• Principle 1: Listen. Try to focus on the speaker’s words.

• Principle 2: Prepare before you communicate.
• Principle 3: Someone should facilitate the activity.
• Principle 4: Face-to-face communication is best.
• Principle 5: Take notes and document decisions
• Principle 6: Strive for collaboration.
• Principle 7: Stay focused.
• Principle 8: If something is unclear, draw a picture.
• Principle 9: Once you agree to something, move-on. If you can’t agree to something,
move-on.
• Principle10: Negotiation is not a contest or a game. It works best when both parties win
Planning Principles:
• Principle 1: Understand the scope of the project.
• Principle 2: Involve stakeholders in the planning activity.
• Principle 3: Recognize that planning is iterative.
• Principle 4: Estimate based on what you know.
• Principle 5: Consider risk as you define the plan.
• Principle 6: Be realistic
• Principle 7: Adjust granularity as you define the plan.
• Principle 8: Define how you intend to ensure quality.
• Principle 9: Track the plan frequently and make adjustments as required.
• Principle 10: Describe how you intend to accommodate change.
Modeling Principles:
Principle 1: The primary goal of the software team is to build software, not create models.
Principle 2: Travel-light, don’t create more models than you need.
Principle 3: Strive to produce the simplest model that will describe the software.
Principle 4: Build models in a way that makes them amenable to change.
Principle 5: Be able to state an explicit purpose for each model that is created.
Principle 6: Adapt the models you develop to the system at hand.
Principle 7: Try to build useful models, but forget about building perfect models.
Principle 8: Don’t become dogmatic about the syntax of the model.
Principle 9: If your instincts tell you a model isn’t right even though it seems okay on paper.
Principle 10: Get feedback as soon as you can.
Requirements modeling principles:
Principle1: The information domain of a problem must be represented and understood.
Principle 2: The functions that the software performs must be defined.
Principle 3: The behavior of the software must be represented.
Principle 4: The models that depict information, function, and behavior must be
partitioned in a manner that uncovers detail in a layered fashion.
Principle 5: The analysis task should move from essential information toward
implementation detail.
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. In modern software engineering
work, coding may be
(1) The direct creation of programming language source code (e.g., Java),
(2) Automatic generation of source code using an intermediate design-like representation of
component to built.
(3) Automatic generation of executable code using a “fourth-generation programming
language”.
The initial focus of testing is at the component level, often called unit testing. Other levels of
testing include
(1) Integration testing(conducted as the system is constructed),
(2) Validation testing that assesses whether requirements have been met for the complete
system
(3) Acceptance testing that is conducted by the customer in an effort to exercise all required
features and functions.
Coding Principles:
• Understand of the problem you’re trying to solve.
• Understand basic design principles and concepts.
• Pick a programming language that meets the needs 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:
• 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.
• Create a visual layout (e.g., indentation and blank lines) that aids understanding.
Validation Principles:
• Conduct a code walkthrough when appropriate.
• Perform unit tests and correct errors you’ve uncovered.
• Re-factor the code.

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:
• Customer expectations for the software must be managed.
• A complete delivery package should be assembled and tested.
• A support regime must be established before the software is delivered.
• Appropriate instructional materials must be provided to end users.
• Buggy software should be fixed first, delivered later.