Software Process Model_Se lect4 btech


Published on

Published in: Education, Technology
  • Be the first to comment

  • Be the first to like this

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide
  • Agile methods are adaptive rather than predictive. Engineering methods tend to try to plan out a large part of the software process in great detail for a long span of time, this works well until things change. So their nature is to resist change. The agile methods, however, welcome change. They try to be processes that adapt and thrive on change, even to the point of changing themselves. Agile methods are people-oriented rather than process-oriented. The goal of engineering methods is to define a process that will work well whoever happens to be using it. Agile methods assert that no process will ever make up the the skill of the development team, so the role of a process is to support the development team in their work.
  • The XP Gang: Scrum: Adaptive: Kent Beck Mike Beedle Jim Highsmith Ward Cunningham Ken Schwaber Martin Fowler Jeff Sutherland James Grenning Ron Jeffries Robert C. Martin FDD: DSDM: Crystal and MPP: Jon Kern Arie van Bennekum Alistair Cockburn Schlaer/Mellor: Independents: Steve Mellor Andrew Hunt Brian Marick Dave Thomas
  • Different Roles within the Extreme Programming methodology work with some of the practices more than others. This “Circle of Life” diagram (adapted from Ron Jefferies papers on XP) shows how the customer is more involved with the “outer ring” practices, the team is involved in all practices, and developers, or pairs of developers are involved in some of the “inner ring” practices.
  • Software Process Model_Se lect4 btech

    1. 1. What are the different types ofSoftware Process Model?
    2. 2. SW Process Models• Waterfall model• Evolutionary or Progressive models• Component-based development model• Iterative Model• Agile Methodology 2
    3. 3. Types of Agile Methodology• Extreme Programming (XP)• Scrum• Agile Modeling• Agile Unified Process (AUP)• Dynamic Systems Development Method (DSDM)• Essential Unified Process (EssUP)• Exia Process (ExP)• Feature Driven Development (FDD)• Open Unified Process (OpenUP)• Crystal Clear• Velocity tracking
    4. 4. Waterfall model• History• Characteristic• Advantages• Disadvantages
    5. 5. The Waterfall Model• Oldest model, it’s been around since 1970.• Called “Linear Sequential Model”.• Most widely used model for SW engineering• Documentation is produced at each stage. 5
    6. 6. Phases1. Requirements analysis and definition2. System and software design3. Implementation and unit testing4. Integration and system testing5. Operation and maintenance 6
    7. 7. Waterfall model diagram
    8. 8. Disadvantages• Inflexible partitioning of the project into distinct stages makes it difficult to respond to changing customer requirements.• Only appropriate when the requirements are well- understood and changes will be fairly limited during the design process.• The waterfall model is mostly used for large systems engineering projects. 8
    9. 9. What are Evolutionary Models
    10. 10. Evolutionary Models 10
    11. 11. What are Exploratory Models• Features• Advantages• Disadvantages
    12. 12. The Exploratory Model Objective is to work with customers and evolve a final system from an initial outline specification. Should start with well-understood requirements and add new features as proposed by the customer.
    13. 13. The Exploratory Model Concurr ent activities Initial Specification version Outline Intermedia te description Development versions Final Valida tion version 13
    14. 14. The Exploratory Model• Problems – Lack of process visibility; – Systems are often poorly structured;• Applicability – For small or medium-size interactive systems; – For parts of large systems (e.g. the user interface); – For short-lifetime systems. 14
    15. 15. What are Prototyping Models• Features• Advantages• Disadvantages
    16. 16. The Prototyping ModelWhen a customer defines a set of general objectives for a software but does not identify detailed input, processing, or output requirement.It consists of the iterating phases: 1. Requirements gathering 2. Design and build SW prototype 3. Evaluate prototype with customer 4. Refine requirements 16
    17. 17. The Prototyping Model 17
    18. 18. The Prototyping Model• Advantages – Users get a feel for the actual system – Developers get to build something immediately – Specifications can be developed incrementally• Disadvantages – The developer may make implementation compromises in order to get a prototype working quickly. – The process in not visible (few documents that reflect every version of the system) – Systems poorly structured 18
    19. 19. What is Component BasedSoftware Engineering (CBSE)• Features• Advantages• Disadvantages
    20. 20. Component Based SoftwareEngineering (CBSE)• Based on systematic reuse where systems are integrated from existing components.• Process stages – Component analysis; – Requirements modification; – System design with reuse; – Development and integration.• This approach is becoming increasingly used as component standards have emerged. 20
    21. 21. Component Based SoftwareEngineering (CBSE) Requirements Component Requirements System design specification analy sis modification with reuse Development Sy stem and integ ration validation 21
    22. 22. Component Based SoftwareEngineering (CBSE)• Advantages: – Reduce amount of software to be developed – Reduce costs and risks – Faster delivery• Disadvantages: – Requirements compromises, system does not meet real needs of users – Limited features 22
    23. 23. Iterative Model and its Types
    24. 24. Iterative Models 24
    25. 25. Advantages and Disadvanates• Incremental Model• Spiral Model• Agile Model
    26. 26. The Incremental ModelRather than deliver the system as a single delivery, the development and delivery is broken down into increments with each increment delivering part of the required functionality.User requirements are prioritised 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.
    27. 27. The Incremental Model Define outline Assign requirements Design sy stem requirements to increments architectur e Develop sy stem Valida te Integ rate Validate increment increment increment sy stem Final sy stem Sy stem incomplete 27
    28. 28. The Incremental ModelAdvantages:• 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. 28
    29. 29. The Incremental ModelDisadvantages:• Increments should be relatively small (20,000 lines of code)• Can be difficult to map the customer’s requirements onto increments of the right size• Hard to identify common functions 29
    30. 30. The Spiral Model• Defined by Barry Boehm in his 1988 article A Spiral Model of Software Development and Enhancement.• Process is represented as a spiral rather than as a sequence of activities with backtracking.• Each loop in the spiral represents a phase in the process.• Suitable for large, expensive and complicated projects 30
    31. 31. The Spiral Model Deter mine objecti ves, Evalua te alterna tives, alterna tives and identify, resolv e risks constr aints Risk anal ysis Risk anal ysis Risk Oper a- anal ysis Pr ototype 3 tional Prototype 2 protoype Risk REVIEW anal ysis Proto- type 1 Requir ements plan Simula tions , models , benchmar ks Life-cy cle plan Concept of Oper a tion S/W requir ements Product design Detailed Requir ement design De velopment plan valida tion Code Unit test Integ ra tion Design V&V Integ ra tion and test plan Plan ne xt phase test Acceptance 31 Service test De velop , verify ne xt-le vel pr oduct
    32. 32. The Spiral ModelAdvantages:• Risks are explicitly assessed and resolved throughout the process.• Software engineers can start working on the project earlier rather than wading through a lengthy early design process. 32
    33. 33. The Spiral ModelDisadvantages:• Requires highly skilled people in risk analysis and planning• Requires more time, and is more expensive• Estimates of budget and time are harder to judge at the beginning of the project since the requirements evolve through the process 33
    34. 34. Latest Techniques of Software Process Management (SPM) AGILE & EXTREME PROGRAMMING
    35. 35. Covered Topics• What is Agile Programming• What is Extreme Programming (XP)• Why would I use Extreme Programming?• Values of XP• Principals of XP• Activities of XP• Dangers of XP
    36. 36. What is “Agility”?
    37. 37. What is “Agility”? • Effective (rapid and adaptive) response to change • Effective communication among all stakeholders • Drawing the customer onto the team Yielding … • Rapid, incremental delivery of softwareSWE 418 (062) Agile Software Processes-XP 37
    38. 38. Agile properties
    39. 39. The Agile Manifesto–a statement ofvaluesIndividuals and Individuals and over Process and tools Process and toolsinteractions interactions Comprehensive ComprehensiveWorking softwareWorking software over documentation documentationCustomer collaborationCustomer collaboration over Contract negotiation Contract negotiationResponding to changeResponding to change over Following a plan Following a plan Source:
    40. 40. Agile properties• Other Models • Agile• Predictive • Adaptive• Process-Oriented • People-Oriented
    41. 41. Characteristics of an Agile process
    42. 42. An Agile process• Is driven by customer descriptions of what is required (Scenarios)(User Stories)• Recognizes that plans are short-lived• Develops software iteratively with a heavy emphasis on construction activities• Delivers multiple ‘software increments’• Adapts as changes occurSWE 418 (062) 42
    43. 43. Basic Building Blocks ofAgile Software Development
    44. 44. Basic Building Blocks ofAgile Software Development  Individuals and interactions over processes and tools;  Working software over comprehensive documentation;  Customer collaboration over contract negotiation;  Responding to change over following a plan.
    45. 45. What Is Extreme Programming?
    46. 46. Definition What Is Extreme Programming? “Extreme Programming (XP) is one of a growing group of agile software development methodologies. XP uses integrated teams of programmers, customers, and managers to develop high-quality software at high speed”. XP Team Programmers Customers Managers
    47. 47. Definition• Extreme Programming differs from traditional methodologies primarily in placing a higher value on adaptability than on predictability.• In XP “Working software is the primary measure of progress.”
    48. 48. Other Agile Processes• The Crystal Methodology Family:• Scrum:• Adaptive Software Development:• DSDM (Dynamic System Development Method):
    49. 49. What is different in XP
    50. 50. XP is Different• Early, concrete, and continuous feedback from short-cycles.• Incremental planning approach.• Flexibility of scheduling the implementation based on changing business needs.• Reliance on tests written by the programmers.• Reliance on the collaboration of programmers. SWE 418 (062) Agile Software Processes-XP 50
    51. 51. What are the Core XP Practices
    52. 52. The Core XP PracticesRapid, fine feedback: Shared Understanding:  Test-driven design (via unit and – Simple Design acceptance tests) – Collective Code Ownership  On-site customer – Coding Conventions  Pair programmingContinuous process: Developer Welfare:  Continuous integration  Forty-hour week  Merciless refactoring  Small, frequent releases
    53. 53. Compare• Waterfall• Iterative• XP
    54. 54. Software Processes Waterfall Iterative XP Analysis Design Code Test Kent Beck 1999SWE 418 (062) Agile Software Processes-XP 54
    55. 55. Waterfall methodAgile Developmentprocess
    56. 56. Responsibilities of….• Customer• Team• Developer Pair
    57. 57. “Circles of Life” On-site Customer Coding Metaphor Standards Refactoring Customer Team Developer Pair – Team – CustomeAcceptance Unit Tests Pair Release Tests Programming Planning Continuous Collective Integration Simple Design Ownership Sustainable Pace Small Releases
    58. 58. Steps of XP
    59. 59. Steps of XP
    60. 60. The XP Key Points• Find ways to make change cheaper• Find inexpensive ways of avoiding errors• Reduce overall cost of development
    61. 61. Thinking of Extreme Programming• The main aim of XP is to reduce the cost of change.• In traditional system development methods the requirements for the system are determined at the beginning of the development project and often fixed from that point on.• This means that the cost of changing the requirements at a later stage (a common feature of software engineering projects) will be high.
    62. 62. Traditional Development exponentialcurve vs. Extreme Programming Curve
    63. 63. Why would I use ExtremeProgramming?• Most software projects use an ad-hoc approach to development known as “code and fix".• Several studies have found that 40% to 80% of a typical software projects budget goes into fixing defects that were created earlier on the same project.• So to lower this curve of change XP is used.
    64. 64. Why would I use ExtremeProgramming?• “Requirements-Analysis-Design-Code-Test-maintain” as a assembly line.  Assumption that the shape of the finished product is known before the process begins.• But, if a customer specify something completely new and needs constant feedback to validate their choices. Then XP comes into scene.
    65. 65. Activities of Extreme Programming• Listening : For the programmers to find what the functionality of the system should be, they have to listen to business.• Designing :One can come a long way without designing but at a given time one will get stuck. The system becomes too complex and there may be dependencies within the system. XP Milestones Listening Designing Coding Testing
    66. 66. Activities of Extreme Programming• Coding : The only truly important product of the system development process is code (a concept to which they give a somewhat broader definition than might be given by others). Without code you have nothing.• Testing: One cannot be certain of anything unless one has tested it. XP Milestones Listening Designing Coding Testing
    1. A particular slide catching your eye?

      Clipping is a handy way to collect important slides you want to go back to later.