Download
devon m simmonds university of north carolina wilmington n.
Skip this Video
Loading SlideShow in 5 Seconds..
CSC450 Software Engineering PowerPoint Presentation
Download Presentation
CSC450 Software Engineering

CSC450 Software Engineering

376 Views Download Presentation
Download Presentation

CSC450 Software Engineering

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Devon M. Simmonds University of North Carolina, Wilmington Software Development Process & Software Process Models CSC450Software Engineering

  2. Outline • Software engineering process • Process characteristics • Software process models • Process framework/maturity • Process benefits • Personal and Team software processes

  3. What is a software process? • A set of activities whose goal is the develop or evolve software. • A series of steps involving activities, constraints, and resources that produce an intended output. • A sequence of steps required to develop or maintain software. (Watts Humphrey) • Why do we need software processes?

  4. Software Design Requirements Analysis Implementation Systems Engineering Testing Deployment Evolution Generic software process activities • Generic activities in all software processes are lifecycle activities – These include: • Specification - what the system should do and its development constraints • Development - production of the software system • Validation - checking that the software is what the customer wants • Evolution - changing the software in response to changing demands

  5. Components of the Circulatory System Process models • An abstract representation of a process presented from a specific perspective. • The Circulatory System perspective • Flow of blood in CS • Blood vessels of the CS • Role of circulatory system in digestion.

  6. Software process models • An abstract representation of a software process presented from a specific perspective. • Workflow perspective represents inputs, outputs and dependencies. • Data-flow perspective represents data transformation activities. • Role/action perspective represents the roles/activities of the people involved in software process.

  7. Generic Software Process Models • Code and Fix • The waterfall model • Separate and distinct phases of specification and development • Incremental & iterative models • Specification and development are interleaved • RAD, Unified Process, etc. • Evolutionary models • Spiral, prototyping • Formal models • A mathematical system model is formally transformed to an implementation • Component-based software development • The system is assembled from existing components • The Unified Process

  8. “Code and Fix” Model • Process • code, test, debug • Problems • requirements analysis and design ignored • code does not evolve gracefully • debugging is difficult (why?)

  9. Waterfall Model Systems Engineering Requirements Analysis Software Design • Proposed by Royce in response to desire to structure software development process. • Phases similar to phases used to develop hardware. Implementation and Testing Operation and Evolution

  10. Systems Engineering Requirements Analysis Software Design Implementation and Testing Operation and Evolution Problems with Waterfall Model • Treats development as a manufacturing process • Model is optimized for hardware development. • Does not take into consideration problem-solving nature of development. • Does not support design a little, code a little problem solving strategy (Takes static view of requirements). • Lack of feedback between phases (Boehm introduced feedback) • Hard dates on phases • Lack of completion criteria for analysis and design • No insight given into how each activity transforms an intermediate product into another. • Little guidance on how to handle changes to products and activities. • Summary: Has difficulty accommodating change after the process is underway

  11. Systems Engineering Requirements Analysis Software Design Implementation and Testing Operation and Evolution Waterfall model usage • Model is appropriate when the requirements are well-understood Waterfall model describes a process of stepwise refinement • Based on hardware engineering models • Widely used in military and aerospace industries

  12. The V Model Requirements Analysis Acceptance Test Architectural Design System Test Subsystem Design Integration Test Detailed Design Module Test Implementation Unit Test

  13. Incremental and Iterative Models Build 1 Build 2 Build 3 DEVELOPERS USERS Release 1 Release 2 Release 3

  14. Iterative Development – edit, modify, refactor, even if no new features are added Incremental/Iterative Development Incremental Development – add new features each iteration

  15. Incremental development

  16. Incremental development • 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

  17. Benefits of Iterative/Incremental Development • Opportunity to learn about problem as design is developed. • Users get a product early and can provide feedback for future builds. • Unanticipated problems can be fixed globally in future releases. • Different releases can focus on enhancements that require specialized expertise. • Incremental development: Each build focuses on a subset of functionality, thus simplifying development. • Approach lowers risk of overall project failure

  18. Problems of Iterative/Incremental Development • If builds are not properly planned, evolution can result in complex system. • Backward compatibility can limit elegance of future releases. • An error in the basic architecture of the system may require changes to basic structure that invalidate earlier releases.

  19. Evolutionary development

  20. Evolutionary Models: Prototyping

  21. Sector Evolutionary Models: The Spiral Model

  22. Spiral Model II

  23. Spiral development • 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. • No fixed phases such as specification or design - loops in the spiral are chosen depending on what is required • Risks are explicitly assessed and resolved throughout the process

  24. Evolutionary development • Problems • Lack of process visibility • Systems are often poorly structured • Special skills (e.g. in languages for rapid prototyping) may be required • Applicability • For small or medium-size interactive systems • For parts of large systems (e.g. the user interface) • For short-lifetime systems

  25. Component-based Software Development (CBSD) • Based on systematic reuse where systems are integrated from existing components or COTS (Commercial-off-the-shelf) systems • Process stages • Component analysis • Requirements modification • System design with reuse • Development and integration • Approach becoming more important • Experience still limited

  26. The Unified Process Increment 3 Increment 2 Increment 1 Inception Inception Inception Elaboration Elaboration Elaboration Construction Construction Construction Transition Transition Transition Production Production Production etc.

  27. The Unified Process End of development, start of delivery, deployment & feedback. Develop or acquire components, Update models, Unit/integration testing. Use cases used to develop test suite for acceptance testing. Typical deployment activities Communication & Planning Communication & Modeling Inception Elaboration Construction Transition Production Business requirements (use cases), Rough architecture, Plan for incremental development Requirements model, design model, implementation model, deployment model. Code for one or more increments, Test suite for acceptance testing. User manual, Developers manual, Installation guide, Stable software release. Defect reports, Requests for changes

  28. The Unified Process

  29. The Unified Process (UP) inception elaboration inception

  30. UP Work Products

  31. Formal systems development • Based on the transformation of a mathematical specification through different representations to an executable program • Transformations are ‘correctness-preserving’ so it is straightforward to show that the program conforms to its specification

  32. Formal systems development • Problems • Need for specialised skills and training to apply the technique • Difficult to formally specify some aspects of the system such as the user interface • Applicability • Critical systems especially those where a safety or security case must be made before the system is put into operation

  33. Other Process Models • Transformational • formal models mechanically transformed to code • Operational • building of a requirements specification that is executable

  34. Process Models Overview • Software process models can be classified along a spectrum ranging from: • radical: all activities carried out in parallel • conservative: all activities carried out in a strict sequence with no overlap. • None of the extremes are viable.

  35. Choosing a Model • Choice depends on nature of project: • Are requirements clearly defined and stable? • Is there pressure to produce a working product quickly? • Are the consequences of operational errors serious?

  36. Radical vs. Conservative Models • More radical models suitable when: • quick results are needed • requirements are fuzzy or unstable • More conservative models suitable when: • consequences of errors are very serious • requirements are well-understood and stable

  37. Software Process Framework

  38. A Process Framework • Process framework • Framework activities • work tasks • work products • milestones & deliverables • QA checkpoints • Umbrella Activities

  39. Framework Activities • Communication • Planning • Modeling • Analysis of requirements • Design • Construction • Code generation • Testing • Deployment

  40. Umbrella Activities • Software project management • Formal technical reviews • Software quality assurance • Software configuration management • Work product preparation and production • Reusability management • Measurement • Risk management

  41. The Process Model:Adaptability • The framework activities will always be applied on every project ... BUT • the tasks (and degree of rigor) for each activity will vary based on: • the type of project • characteristics of the project • common sense judgment; concurrence of the project team

  42. Elements of Process Descriptions • Each activity has an entry and exit criteria. • Activities are organized in a sequence. • Every process has a set of guiding principles that explain goals of each activity. • A process may be composed of subprocesses.

  43. Process Maturity:Capability Maturity Model Integration (CMMI) • A framework to determine process maturity • Initial: Few defined processes; success depends on individual effort. • Repeatable: Cost, schedule, and product tracking processes in place. • Defined: Standard processes are defined and used. • Managed: Defined processes and product qualities are meaningfully measured. • Optimizing: Measures used to improve process/product. • Current Status: http://www.sei.cmu.edu/cmmi/adoption/pdf/cmmi-overview07.pdf (page 34) Defined Repeatable Managed Initial Optimizing

  44. Process Assessment and Improvement

  45. What are the benefits of a defined software processes? A defined process: • facilitates communication about the process • provides a basis for process automation • facilitates process reuse • facilitates process evolution • aid process management

  46. Essence of Software Development Requirements Statement validation correspondence correctness verification Design Implementation

  47. Impedance mismatches As Management requested it. As the Project Leader defined it. As Systems designed it. As Programming developed it. As Operations installed it. What the user wanted. (Pre-1970 cartoon; origin unknown)

  48. Personal and Team Process Models

  49. Personal Software Process (PSP) • Recommends five framework activities: • Planning • High-level design • High-level design review • Development • Postmortem • stresses the need for each software engineer to identify errors early and as important, to understand the types of errors

  50. Team Software Process (TSP) • Each project is “launched” using a “script” that defines the tasks to be accomplished • Teams are self-directed • Measurement is encouraged • Measures are analyzed with the intent of improving the team process