software lifecycle software lifecycle basics lifecycle models methods and tools

of 27 /27
Software Lifecycle Software Lifecycle Basics Lifecycle Models Methods and Tools

Post on 22-Dec-2015




7 download

Embed Size (px)


  • Slide 1
  • Software Lifecycle Software Lifecycle Basics Lifecycle Models Methods and Tools
  • Slide 2
  • Topic 2Software Lifecycle2 A series of steps through which a software product progresses Lifetimes vary from days to months to years Consists of people! overall process intermediate products stages of the process
  • Slide 3
  • Topic 2Software Lifecycle3 Software Production Personnel Client individual or organization that wants product to be developed Developer(s) (members of) organization producing product User person on whose behalf client has commissioned developer, person(s) who will utilize software in operation
  • Slide 4
  • Topic 2Software Lifecycle4 Kinds of SW projects Internal software development: user = client = developer Contract software development: user = client developer Commercial software development:user client = developer.
  • Slide 5
  • Topic 2Software Lifecycle5 Quality Products through Process Quality software products developed through systematic software processes with explicit product quality requirements Effective testing and analysis must be included incremental analysis activities to complement synthesis activities Powerful tools and processes are essential to assure effectiveness
  • Slide 6
  • Topic 2Software Lifecycle6 What is a Process? Device for producing a product (getting job done) Indirect nature Process description (program) created to describe wide class of instances Humans create process descriptions (models or programs) to solve classes of problems Software Processes: stratagem for creating and evolving software products
  • Slide 7
  • Topic 2Software Lifecycle7 Major Components of a Lifecycle Model: Phases Intermediate Products Reviews Major Components of a Lifecycle Model: Phases Intermediate Products Reviews The Lifecycle Approach Phasing promotes manageability and provides organization Intermediate software products promote visibility and assure continuity between phases Reviews assure ultimate satisfaction of requirements
  • Slide 8
  • Topic 2Software Lifecycle8 Phases of a Software Lifecycle Standard Phases Requirements Analysis and Specification Design Implementation and Integration Operation and Maintenance Testing throughout! Requirements changes inevitable!
  • Slide 9
  • Topic 2Software Lifecycle9 Intermediate Software Products Objectives: Demarcate end of phases Enable effective reviews Specify requirements for next phase Form: Rigorous Machine processible Content: Specifications Tests Documentation
  • Slide 10
  • Topic 2Software Lifecycle10 Lifecycle Reviews Reviews conducted with each phase Review intermediate software products Objectives Validate that inspected specification conforms with requirements and/or verify that it conforms to product resulting from previous phase Detect points of non-conformance Discover all defects currently present in the product under development (as early as possible) Detect defects in software specification Detect defects in a specification's representation Measure product quality Measure development process Evaluate techniques and tools Feedback for specifiers to improve Feedforward for process and quality control Feedback for specifiers to improve Feedforward for process and quality control
  • Slide 11
  • Topic 2Software Lifecycle11 Requirements Analysis and Specification Problem Definition > Requirements Specification determine exactly what client (and user) wants and process constraints develop a contract with client what task the product is to do Difficulties client asks for wrong product client is computer/software illiterate specifications may be ambiguous, inconsistent, incomplete Validation extensive specification reviews to check that requirements specification satisfies client needs look for ambiguity, consistency, incompleteness check for feasibility, testability develop system/acceptance test plan
  • Slide 12
  • Topic 2Software Lifecycle12 Design Requirements Specification > Design develop architectural design (system structure): decompose software into modules with module interfaces develop detailed design (module specifications): select algorithms and data structures maintain record of design decisions and traceability how the product is to do its task Difficulties miscommunication between module designers design may be inconsistent, incomplete, ambiguous Verification extensive design reviews (inspections with checklists) to determine that design conforms to requirements check module interactions develop integration test plan
  • Slide 13
  • Topic 2Software Lifecycle13 Implementation and Integration Design > Implementation implement modules and verify they meet their specifications combine modules according to architectural design how the product does its task Difficulties module interaction errors order of integration has a critical influence on quality and productivity Verification and Testing extensive code reviews (inspections with checklists) to determine that implementation conforms to requirements and design develop and test on unit/module test plan: focus on individual module functionality test on integration test plan: focus on module interfaces test on system test plan: focus on requirements and determine whether product as a whole functions correctly
  • Slide 14
  • Topic 2Software Lifecycle14 Operation and Maintenance Operation > Change maintain software after (and during) user operation integral part of process determine whether product as a whole still functions correctly Difficulties design not extensible lack of up-to-date documentation personnel turnover Verification and Testing extensive review to determine that change is made correctly and all documentation updated test to determine that change is correctly implemented test to determine that no inadvertent changes were made to compromise system functionality (check that no affected software has regressed)
  • Slide 15
  • Topic 2Software Lifecycle15 Lifecycle Models Over time different lifecycle models developed, e.g., build-and-fix model waterfall model prototyping model incremental model spiral model . Different lifecycle models decompose software engineering activities in different ways and are applicable for different applications and organizations No "right" or "wrong" lifecycle model
  • Slide 16
  • Topic 2Software Lifecycle16 Build First Version Retirement Operations Mode Modify until client is satisfied Build-and-Fix Is this your usual model?
  • Slide 17
  • Topic 2Software Lifecycle17 Requirements Verify Retirement Operations Test Implementation Verify Design Req. Change Waterfall (collapsed) Key features: - requirements phase - intermediate products - V & V steps Key features: - requirements phase - intermediate products - V & V steps
  • Slide 18
  • Topic 2Software Lifecycle18 Rapid Prototype Verify Retirement Operations Test Implementation Verify Design Req. Change Rapid Prototyping Key feature: - prototype Key feature: - prototype
  • Slide 19
  • Topic 2Software Lifecycle19 For each build: Perform detailed design, implement. Test. Deliver. Requirements Verify Retirement Operations Verify Arch. Design Incremental Key features: - incremental delivery - frequent builds Key features: - incremental delivery - frequent builds
  • Slide 20
  • Topic 2Software Lifecycle20 The Spiral Model [Boehm,1988]
  • Slide 21
  • Topic 2Software Lifecycle21 Add a Risk Analysis step to each phase! Add a Risk Analysis step to each phase! Requirements Verify Retirement Operations Test Implementation Verify Design Req. Change Risk Assessment (Extremely) Simplified Spiral Model
  • Slide 22
  • Topic 2Software Lifecycle22 Synchronize-and-Stabilize Requirements phase similar to Waterfall model Features are divided into builds or versions Synchronize: code is integrated at the end of each day, then tested and debugged Stabilize: when all features of a build are completed and known faults are fixed Always have a working version of the product Used successfully by Microsoft Design phase is de-emphasized
  • Slide 23
  • Topic 2Software Lifecycle23 Extreme Programming Based on incremental model Potential features are identified, along with cost (similar to requirements phase) Initial features are chosen based on cost-benefit analysis Implementation proceeds by programming pairs Design is de-emphasized No specialization among team members; ego-less programming
  • Slide 24
  • Topic 2Software Lifecycle24 Software Methods and Tools Methods provide a means or procedure for accomplishing a task Tools are devices for performing some task analytical tools software tools Methodology guides the proper use of methods and tools Process helps to enact a methodology Environments are a synergistic collection of tools with process support
  • Slide 25
  • Topic 2Software Lifecycle25 Analytical Tools Problem solving techniques that help in software development cost-benefit analysis compare expected benefits against estimated costs stepwise refinement divide and conquer abstraction focus on some important property and ignore (for the time being) irrelevant details Analytical tools underlie many software development methods
  • Slide 26
  • Topic 2Software Lifecycle26 Software Tools Software tools are an automated implement for performing a task Tools facilitate work because they are fast, immune to boredom and "cheating" Ideal Software Tools are... powerful, effective, convenient, natural, reliable, robust Most software development tools are not exceptions: compilers, editors, loaders these have been polished, refined, and debugged through long-term use and hence made reliable and robust these have been made natural and effective through extended exposure and maintenance
  • Slide 27
  • Topic 2Software Lifecycle27 Tool Obstacles Tool use obstacles developers tend to be like hammer and screwdriver carpenters tools are not powerful and/or effective tools are unreliable and/or unrobust comes with time and money tools are inconvenient and/or unnatural comes from successful use Tool building obstacles Short history of large-scale software development Limited success in developing software well exploiting tools successfully Few software techniques have had time and use required to achieve tool status No tools at all in some key areas (e.g., real-time analysis)