Agile Requirements Methods 1. Mitigating Requirements Risk  The purpose of a software method is to mitigate risks inherent in the project.  The purpose.

Slides:



Advertisements
Similar presentations
Prescriptive Process models
Advertisements

SOFTWARE DEVELOPMENT METHODOLOGIES Methodologies Waterfall Prototype model Incremental Iterative V-Model Spiral Scrum Cleanroom RAD DSDM RUP.
Software Life Cycle Requirements analysis System design Program design Program implementation (coding) Unit testing Integration testing System testing.
Chapter 4: Inception is Not the Requirements Phase
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 17 Slide 1 Rapid software development.
Rapid software development
Alternate Software Development Methodologies
SCRUM John Drew. SCRUM - overview Scrum is a project management discipline that has evolved since the early 1990s to deliver software that meets business.
Rational Unified Process
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 17 Slide 1 Chapter 17: Rapid software development November 3, 2008.
Computer Engineering 203 R Smith Requirements Management 6/ Requirements IEEE Standard Glossary A condition or capability needed by a user to solve.
Recall The Team Skills 1. Analyzing the Problem 2. Understanding User and Stakeholder Needs 3. Defining the System 4. Managing Scope 5. Refining the System.
Administrivia Lifecycle Architecture (LCA) group assignment will go out later today. Informal feedback meetings with LCO groups EasyShare: Mon, 2:45pm-3:15pm,
Chapter 30 Agile Requirements Methods. Mitigating Requirements Risk  The entire requirements discipline within the software lifecycle exists for only.
COMP 350: Object Oriented Analysis and Design Lecture 2
Software Architecture Quality. Outline Importance of assessing software architecture Better predict the quality of the system to be built How to improve.
Recall The Team Skills Analyzing the Problem
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 17 Slide 1 Rapid software development.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 17 Slide 1 Extreme Programming.
Chapter 30 Agile Requirements Methods. Mitigating Requirements Risk  The entire requirements discipline within the software lifecycle exists for only.
Principles of Object Technology Module 1: Principles of Modeling.
RUP Requirements RUP Artifacts and Deliverables
CPTE 209 Software Engineering Summary and Review.
Introduction to RUP Spring Sharif Univ. of Tech.2 Outlines What is RUP? RUP Phases –Inception –Elaboration –Construction –Transition.
Chapter 3 – Agile Software Development 1Chapter 3 Agile software development.
BEFORE AGILE METHODS Other Engineering fields development models were used, ie: Waterfall Method: Intensive planning and refactoring before coding is actually.
Chapter 5 Software Process Models. Problems with “Traditional” Processes 1.Focused on and oriented towards “large projects” and lengthy development time.
Current Trends in Systems Develpment
Extreme Programming(XP)
Describing Methodologies PART II Rapid Application Development* Systems Analysis and Design II.
Unified Process versus Extreme Programming. Outline Compare and contrast UP and XP  Processes / Disciplines  Management  Artefacts Risk management.
©Ian Sommerville 2000, Mejia-Alvarez 2009 Slide 1 Software Processes l Coherent sets of activities for specifying, designing, implementing and testing.
Identify steps for understanding and solving the
From Use Cases to Test Cases 1. A Tester’s Perspective  Without use cases testers will approach the system to be tested as a “black box”. “What, exactly,
10/12/ Recall The Team Skills 1. Analyzing the Problem (with 5 steps) 2. Understanding User and Stakeholder Needs 1. Interviews & questionnaires.
Extreme/Agile Programming Prabhaker Mateti. ACK These slides are collected from many authors along with a few of mine. Many thanks to all these authors.
Agile Methods Chapter 30. Agile Methods Key points ▫No method fits all projects or organizations ▫In General  A process to elicit, organize, document,
1 Software Process Models-ii Presented By; Mehwish Shafiq.
Rapid software development 1. Topics covered Agile methods Extreme programming Rapid application development Software prototyping 2.
Extreme Programming (XP). Agile Software Development Paradigm Values individuals and interactions over processes and tools. Values working software over.
Requirements Capture. Four Steps of requirements capture List candidate requirements Understand system context Capture functional requirements Capture.
Applied Software Project Management
University of Toronto at Scarborough © Kersti Wain-Bantin CSCC40 other methodologies 1 Method/Process = step-by-step description of the steps involved.
Managing Change 1. Why Do Requirements Change?  External Factors – those change agents over which the project team has little or no control.  Internal.
Rational Unified Process (RUP) Process Meta-model Inception Phase These notes adopted and slightly modified from “RUP Made Easy”, provided by the IBM Academic.
Applied Software Project Management Andrew Stellman & Jennifer Greene Applied Software Project Management Applied Software.
Software Requirements: A More Rigorous Look 1. Features and Use Cases at a High Level of Abstraction  Helps to better understand the main characteristics.
J. Scott Hawker p. 1Some material © Rational Corp. Rational Unified Process Overview See and use the RUP Browser on lab machines.
Chapter 31 Your Prescription for Requirements Management.
Software Engineering 1 Object-oriented Analysis and Design Applying UML and Patterns An Introduction to Object-oriented Analysis and Design and Iterative.
Lecture 4 – XP and Agile 17/9/15. Plan-driven and agile development Plan-driven development A plan-driven approach to software engineering is based around.
Requirements Engineering Requirements Engineering in Agile Methods Lecture-28.
Rational Unified Process (RUP)
Agile. Processes Waterfall Traditional With prototyping Sprial Agile Dynamic Systems Development Method (DSDM) Scrum Crystal eXtreme Programming (XP)
An Agile Requirements Approach 1. Step 1: Get Organized  Meet with your team and agree on the basic software processes you will employ.  Decide how.
Agenda: Overview of Agile testing Difference between Agile and traditional Methodology Agile Development Methodologies Extreme Programming Test Driven.
CS223: Software Engineering Lecture 18: The XP. Recap Introduction to Agile Methodology Customer centric approach Issues of Agile methodology Where to.
Introduction to Software Engineering Muhammad Nasir Agile Software Development(2)
 System Requirement Specification and System Planning.
Your Prescription for Requirements Management 1. Assumptions The prescription for requirements management is based on the following assumptions:  The.
Software Development - Methodologies
Methodologies and Algorithms
Software Development methodologies
Recall The Team Skills Analyzing the Problem
Software Processes (a)
Applying Use Cases (Chapters 25,26)
Extreme Programming.
Rapid software development
Presentation transcript:

Agile Requirements Methods 1

Mitigating Requirements Risk  The purpose of a software method is to mitigate risks inherent in the project.  The purpose of the requirements management method is to mitigate requirements related risks on the project.  No one method fits all projects; therefore, the requirements method must be tailored to the particular project, i.e., appropriate for the types of risks inherent in the development environment. 2

Requirements Techniques and the Project Risks They Address TechniqueRisk Addressed Interviewing  The development team might not understand who the real stakeholders are.  The team might not understand the basic needs of one or more stakeholders. Requirements workshops  The system might not appropriately address classes of specific user needs.  Lack of consensus among key stakeholders might prevent convergence on a set of requirements. Brainstorming and idea reduction  The team might not discover key needs or prospective innovative features.  Priorities are not well established, and a plethora of features obscures the fundamental “must haves”. Storyboards  The prospective implementation misses the mark.  The approach is too hard to use or understand, or the operation’s business purpose is lost in the planned implementation. 3

Requirements Techniques and the Project Risks They Address (Cont’d) TechniqueRisk Addressed Use cases  Users might not feel they have a stake in the implementation process.  Implementation fails to fulfill basic user needs in some way because some features are missing or because of poor usability, poor error and exception handling, etc. Vision document  The development team members do not really understand what system they are trying to build, or what user needs or industry problem it addresses.  Lack of longer-term vision causes poor planning and poor architecture and design decisions. Whole product plan  The solution might lack the commercial elements necessary for successful adoption. Scoping activities  The project scope exceeds the time and resources available. Supplementary specification  The development team might not understand nonfunctional requirements, platforms, reliability, etc. 4

Requirements Techniques and the Project Risks They Address (Cont’d) TechniqueRisk Addressed Tracing use cases to implementation  Use cases might be described but not fully implemented in the system Tracing use case to test cases  Some use cases might not be tested, or alternative and exception conditions might not be understood, implemented, and tested. Requirements traceability  Critical requirements might be overlooked in the implementation  The implementation might introduce requirements or features not called for in the original requirements.  A change in requirements might impact the other parts of the system in unforeseen ways. Change management  New system requirements might be introduced in an uncontrolled fashion. The team might underestimate the negative impact of a change 5

Principles in Designing and Evaluating Software Methodologies 1. Interactive, face-to-face communication is the cheapest and fastest channel for exchanging information. 2. Excess methodology weight is costly. 3. Larger teams need heaver methodologies. 4. Greater ceremony is appropriate for projects with greater criticality. -- Alistair Cockburn [2002] 6

Principal 1: Interactive, Face-to-Face Communication Is the Cheapest and Fastest Channel for Exchanging Information  If the customer is close to the team, if the customer is directly accessible, if requirements can be explained to the team directly, if the analyst can communicate directly with the customer, then less communication is necessary.  However, some requirements must be documented, but the Vision document, used cases, supplementary specifications, etc. can be shorter and written with less specificity. 7

Principle 2: Excess Methodology Weight is Costly  Every unnecessary process or artifact slows the team down and adds weight to the project.  The team must balance the cost and weight of each requirement activity with the associated risks.  If a risk is low consider eliminating or “lightening” the relevant requirements activity or artifact from the project plan. 8

Principle 3: Larger Teams Need Heavier Methodologies  The requirements method must be scaled to the size of the team and the size of the project.  An overweight method will result in lower efficiency for a team of any size. 9

Principle 4: Greater Ceremony Is Appropriate for Projects with Greater Criticality  Criticality may be the most important factor in determining methodology weight.  Even small critical projects may need a heavyweight method.  And a noncritical large project might be able to apply lighter-weight methods. 10

When is Documentation Required?  The documentation communicates an important understanding or agreement in which simpler verbal communication is either impractical or too risky.  The documentation allows new team members to come up to speed more quickly.  Investment in the document has a obvious long- term payoff because it will evolve, be maintained and persist as an ongoing part of the project.  Some company, customer, or regulatory standard imposes a requirement for the document. 11

Key Characteristics of Extreme Programming (XP)  The scope of the application or component permits coding by a team of three to ten programmers working at one location.  One or more customers are on site to provide constant requirements input.  Development occurs in frequent builds or iterations, each of which is releasable and delivers incremental user functionality. 12

Key Characteristics of Extreme Programming (XP) (Cont’d)  The unit of requirements gathering is the user story, a chunk of functionality that provides value to the user. User stories are written by the customers on site.  Programmers work in pairs and follow strict coding standards. They do their own unit testing and are supposed to routinely re-factor the code to keep the design simple.  Since little attempt is made to understand or document future requirements, the code is constantly re-factored (redesigned) to address changing user needs. 13

Applying Extreme Programming Principles to Requirements Risk Mitigation Extreme Programming PrincipleMitigated Requirements Risk Application or component scope is such that three to ten programmers at one location can do the coding. Constant informal communication can minimize of eliminate much requirements documentation. One or more customers are on site to provide constant requirements input. Constant customer input and feedback dramatically reduces requirements-related risk. Development occurs in frequent builds or iterations, each of which is releasable and delivers incremental user functionality. Customer value feedback is almost immediate; this ship can’t go too far off course. The unit of requirements gathering is the user story, a bite of functionality that provides value to the user. Customers on site write user stories. A use case describes sequences of events that deliver value to a user, as written by the developer with user input. User stories are often short descriptions of a path or scenario of a use case. Each captures the same basic intent – how the user interacts with the system to get something done. 14

An Extreme Requirements Method  Concept: It is communicated directly from the customer to the project team – verbally, frequently, and repeatedly as personnel come and go on the team.  Vision: A vision document may not exist and we are dependent on the development team to make the right architectural decisions now – for both now and later.  Requirements: User stories are used instead of use cases (but use cases are probably better). 15

An Extreme Requirements Method (Cont’d)  Supplementary Specification/ Nonfunctional Requirements: Customers probably communicate these directly to programmers.  Tooling: The tools of XP are whiteboards and desktop tools, such as spreadsheets with itemized user stories, priorities, etc. Possibly a tacking database can be used to keep track of the stories. 16

Situations in which an Extreme Method Won’t Work  Your customer can’t be located on site.  You are developing a new class of products for which no current customers exist.  The concepts are so innovative that customers can’t envision what stories they would fulfill.  Your system has to be integrated with either new systems or other existing systems.  More that three to ten people are required.  Your system is so complex that it must be considered as a “system of systems” – with each system imposing requirements on others.  Some of your team member work from remote sites.  A few potential failure modes are economically unacceptable 17

An Agile Requirements Method (A Little Heaver Model)  Concept: It is tested and elaborated by a number of means, including requirements workshops or interviews with prospective customers.  Vision: It is no longer only verbal. It is defined incrementally in a Delta Vision document, which describes the new features to be implemented in a specific release. The whole product plan describes the other elements of the solution.  Requirements: The use-case model defines the use cases at the highest level of abstraction. Each use case has a specification that elaborates the sequence of events, the pre- and post-conditions, and the exceptions and alternative flows. 18

An Agile Requirements Method (Cont’d)  Supplementary Specification/ Nonfunctional Requirements: Requirements must be documented in a supplementary specification.  Tooling: The more people working on the project, and the more locations they work from, the more important version control becomes, both for the code itself and for the use cases and other requirements artifacts that define the system being built. 19

A Robust Requirements Method  Concept: Concepts are validated using a range of techniques such as storyboards, prototypes, etc.  Vision: A complete short and long term vision document must be prepared.  Requirements: The use-cases are elaborated as necessary so that prospective users can validate the implementation concepts. Pre- and post-conditions are specified as clearly and unambiguously as possible. Additional technical specification methods are used as necessary to describe how the system is to work. 20

A Robust Requirements Method (Cont’d)  Supplementary Specification/ Nonfunctional Requirements: The supplementary specification is as complete as possible.  Tooling: Multisite configuration management systems are employed. Requirements tools both support requirements traceability from features through use cases and into test cases and track changes and change history  Project Control: A change control board is created to weigh and decide on possible requirements additions and defect fixes. Requirements analysis and impact assessment activities are performed. 21