Software Engineering I
Oct. 7, 2013 Notes

A primer on software processes

We previously discussed the waterfall method.  If implemented properly, it
is applied as follows:

  Requirements gathering and definition <--> Specification <--> Design <-->

  Implementation <--> Integration and Deployment <-->  Maintenance

  Each step should include software validation and verification.

  See figure 4.2 from the book, but add arrows going back, too.

This model could be broken up for phased releases:

  1. Perform Requirements Gathering <--> Specification <--> Planning

  2. a) For project part 1 perform:

        Design <--> Implementation <--> Integration and Deployment

     b) For project part 2 perform:

        Design <--> Implementation <--> Integration and Deployment

  See figure 4.3 from the textbook, and allow for arrows going back.

Spiral Model

  -See figure 4.5 from the textbook

  -Developed by Barry Boehm

  -Provides a cyclic approach to software development

  -Process is incremental and risk driven

  -Consists of four quadrants within the cycles

    + Determining objectives, alternatives and constraints
    + Evaluating alternatives and identifying and resolving risks
    + Developing and verifying the next level of the product, including
      prototyping
    + Planning for the next phase

Rational Unified Process Framework

  Incorporates incremental and iterative process model and spiral model

  Focus on:

     Use cases
     Requirements gathering/analysis
     Software architecture
     Iterative and incremental engineering

  Develop large software in pieces

  Incrementally work on use cases and requirements gathering, risks, 
  architecture and development for each piece of the software.

  Phases are:

    + Inception
      - Scope and goals
      - Central use cases and scenarios
      - Initial design and SW architecture
      - Project schedule and tangible resources assessment
      - Planning for implementation, testing, integration, etc.
      - Risk estimation
    + Elaboration
      - Establish all major requirements
      - Complete and implement the initial design
      - Complete platform and methodology assessment for implementation
        testing and integration
      - Plan most or all SW tests
      - Set up resources for testing, integration, and development
    + Construction
      - Implement the project
      - Ensure product is at least of alpha version quality
      - Determine remaining goals
    + Transition
      - Prepare to provide SW support
      - Ensure users are able to use the SW and that it is acceptable to them
      - Prepare for release and deployment
      - Ensure SW is ready for general release

  Iterations may occur within each of the steps above.  
  See figure 4.6 from textbook

Agile methods

  According to the textbook, there is not an absolute definition for an agile
  method, but many share characteristics:

    - Short release times and short iterations
    - Incremental design including delayed design decisions
    - User involvement
    - Low level of documentation
    - Informal communication such as short meetings, sticky notes, etc.
    - Constant change

Agile methods may work well for projects with:

    - Short development times
    - Constantly changing requirements
    - Requirements that are not well understood before the project begins

Agile avoids:

    - Complex methodology (RUP actually has about 30 roles and many work 
      products)
    - Duplication of effort, including documentation
    - Reliance upon overtime during a release period

Many methods exist

	XP - extreme programming
	Scrum
	Crystal

We will return to these at a later date.