1. CEN 5011 Advanced Software Engineering
Fall 2004
Instructor: Masoud Sadjadi

2. Acknowledgements Dr. Peter Clarke Dr. Betty Cheng Dr. Bernd Bruegge
Overview:
Dr. Peter Clarke
Dr. Betty Cheng
Dr. Bernd Bruegge
Dr. Allen Dutoit
Introduction
Evaluation
SW Life Cycle

3. Agenda Course Introduction Initial Evaluation Software Life Cycle
Overview:
Course Introduction
Initial Evaluation
Software Life Cycle
Introduction
Evaluation
SW Life Cycle

4. Course Home Page Web Page General Information: Important Links:
Overview:
Web Page
General Information:
Office Hours: ECS 212C, W 14: :00 or by appointment.
Important Links:
Course Syllabus
Project
Class Schedule, Reading Assignments, and Lecture Notes
Class Notices
Please read before coming to class.
Pay attention to the reading assignments.
Introduction
Home Page
SE Overview
Course Outcome
Evaluation
SW Life Cycle

5. Prerequisite and References
Overview:
Prerequisite
CEN 4010
Familiarity with
At least two higher level languages
The foundations of computing
The basic concepts of software engineering
Required Text
Bernd Bruegge and Allen H Dutoit, “Object-Oriented Software Engineering: Using UML, Patterns, and Java.”
Other reading material
Class notes. 
Introduction
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

6. Grading Grading Policy Grading Standard Attendance
Overview:
Grading Policy
Class Attendance and Participation: 10%.
Homework: 20%.
Term Project: 30%.
Mid-Term Exam: 20%.
Final Exam: 20%.
Grading Standard
The grading scale is: A: 90 | A-:87 | B+:84 | B: 80 | B-:77 | C+:74 | C: 70 | C-:65 | D+:60 | D: 55 | D-:50. 
Note that a B- is not a B.
Attendance
Attendance will be taken during each class meeting.
Introduction
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

7. Tentative Course Schedule
Overview:
Week
Date
Deliverables/Exams
Lectures 1
9/1
Introduction. Software engineering overview. 2
9/8
Homework (5%)
Modeling with UML. 3
9/15
Project organization. Requirements elicitation. 4
9/22
Homework (5%)
Requirements elicitation and analysis. 5
9/29
System design: decomposition and goals. 6
10/6
Project deliverable (5%)
Project presentation 1 by students (5%) 7
10/13
Mid-term exam (20%)
Object design: reuse and patterns. 8
10/20
Object design: reuse, patterns, and interfaces. 9
10/27
Homework (5%)
Mapping models to code. 10
11/3
Integration and system testing. 11
11/10
Project deliverable 2 (5%)
Project presentation 2 by students (5%) 12
11/17
Managing change: project management. 13
11/24
Homework (5%)
Transparent shaping of existing software. 14
12/1
Review the course and final exam preparation. 15
12/8
Project Deliverable 3 (5%)
Project presentation 3 by students (5%) 16
12/15
Final exam (20%)
Introduction
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

8. Project Objective and Grading
Overview:
Objective  
The primary objective of this project is to give you practice in applying the phases of the software development process to a "real" software project.
Grading Scheme  
The grade for this project is based on three deliverables and two class presentations, representing 30% of the final grade.  
All students in a project team receive the same grade.
Introduction
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

9. Deliverables and Presentation
Overview:
Introduction
Deliverable 1
Software Requirements  Document (SRD) (5%)
10/6
Due at the beginning of the class.
Presentation 1
A brief description of  SRD.  Details will follow. (5%)
Deliverable 2
Design Document (DD) (5%)
11/10
Presentation 2
A brief description of DD.  Details will follow. (5%)
Deliverable 3
Software documentation consisting of: (5%)
Software Requirements  Document
Design Document
Implementation i.e. code design, and Test Cases
User's Guide
A CD with all project material.
12/8
Presentation 3
A brief description of the software system (5%)
Requirements, design, implementation and test cases.
The presentation should be no more than 20 mins.
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

10. Project and Team Selection
Overview:
Selection of Project:  
Each group is responsible for selecting a project.  
Before starting work on the project you must come and see me during my office hours so that we can decide on the scope of your project.
Project selection should be finalized by the end of Week 2 (Friday, September 10). This means you have to come and see me before September 10.
If you have difficulty in selecting a project I will assist you.
Project Teams  
Each team shall consist of 5 to 6 students.  
Let us decide on team members
Introduction
Home Page
Syllabus
Project
SE Overview
Course Outcome
Evaluation
SW Life Cycle

11. What is Software Engineering? (1)
Overview:
Systematic approach for developing software
“Methods and techniques to develop and maintain quality software to solve problems.” [Pfleeger, 1990]
“Study of the principles and methodologies for developing and maintaining software systems.” [Zelkowitz, 1978]
“Software engineering is an engineering discipline which is concerned with all aspects of software production.” [Sommerville]
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

12. What is Software Engineering? (2)
Overview:
“Practical application of scientific knowledge in the design and construction of computer programs and the associated documentation required to develop, operate, and maintain them.” [Boehm, 1976]
“Deals with establishment of sound engineering principles and methods in order to economically obtain software that is reliable and works on real machines.” [Bauer, 1972]
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

13. Questions Addressed by SE
Overview:
How do we ensure the quality of the software that we produce?
How do we meet growing demand and still maintain budget control?
How do we avoid disastrous time delays?
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

14. Why apply SE to Systems?
Overview:
Provide an understandable process for system development.
Develop systems and software that are maintainable and easily changed.
Develop robust software and system.
Allow the process of creating computing-based systems to be repeatable and manageable.
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

15. How can we apply SE? Modeling Problem-solving Knowledge acquisition
Overview:
Modeling
Problem-solving
Knowledge acquisition
Rationale-driven
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

16. Modeling
Overview:
“A model is an abstract representation of a system that enables us to answer questions about the system.”
Why use a model?
Systems are too large, too small, too complicated, or too expensive, to experience firsthand.
Models allow
Visualization
Comprehension
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

17. Steps in problem solving:
Overview:
Steps in problem solving:
Formulate the problem
Analyze the problem
Search for solutions
Decide on the appropriate solution
Specify the solution
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

18. Knowledge Acquisition
Overview:
Domain specific knowledge.
New knowledge can affect the development process.
Knowledge acquisition is nonlinear – affects several of the software development models.
Risk assessment is important.
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

19. Rationale Management Assumptions made about systems change constantly.
Overview:
Assumptions made about systems change constantly.
Application domain models stabilize, solution domain models are in constant flux.
Changes to the solution models due to:
design and implementation faults
new technology
Need to understand the context in which each design decision was made.
Introduction
Home Page
SE Overview
Definition
How to apply?
Course Outcome
Evaluation
SW Life Cycle

20. Course Outcomes
Overview:
Familiarity with planning and managing large scale software systems.
Mastering the techniques for software requirement elicitation and analysis.
Mastering the techniques for software design.
Mastering the techniques for software implementation.
Familiarity with techniques used to test large scale software systems.
Familiarity with maintaining software and managing change.
Introduction
Home Page
SE Overview
Course Outcome
Evaluation
SW Life Cycle

21. Initial Evaluation Background Survey Initial Assessment
Overview:
Background Survey
To get familiar with your interests in the course.
To understand what topics should be covered.
To get familiar with your research interests.
Initial Assessment
No grading value.
To assess the initial level of your knowledge.
To teach the course at an acceptable level.
To help you fulfill the course requirements.
Introduction
Evaluation
SW Life Cycle

22. Agenda Course Introduction Initial Evaluation Software Life Cycle
Overview:
Course Introduction
Initial Evaluation
Software Life Cycle
Introduction
Evaluation
SW Life Cycle

23. Our Intention Requirements Software Overview: Introduction Evaluation
SW Life Cycle
Requirements
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity
Software

24. Our plan of attack Requirements Analysis Design Implementation Testing
Overview:
Introduction
Requirements
Analysis
Evaluation
SW Life Cycle
Design
Motivation
Terminology
SW Processes
Implementation
SW Life Cycle
Cap. Maturity
Testing
Delivery and Installation

25. How it often goes Requirements Analysis D E L A Y Vaporware Overview:
Introduction
Evaluation
Requirements D E L A Y
SW Life Cycle
Analysis
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity
Vaporware

26. Inherent Problems Requirements are complex
Overview:
Requirements are complex
The client does not know the functional requirements in advance.
Requirements may be changing
Technology enablers introduce new possibilities to deal with nonfunctional requirements.
Frequent changes are difficult to manage
Identifying milestones and cost estimation is difficult.
There is more than one software system
Backward compatible with existing systems
Let’s view these problems as the nonfunctional requirements for a system that supports software development!
This leads us to software life cycle modeling
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

27. Terminology (1) participants – all persons involved in a project.
Overview:
participants – all persons involved in a project.
e.g., developers, project manager, client, end users.
role – associated with a set of tasks assigned to a participant.
system – underlying reality.
model – abstraction of the reality.
work product – an artifact produced during development.
deliverable – work product for client.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

28. Terminology (2)
Overview:
activity – a set of tasks performed toward a specific purpose.
milestone – end-point of a software process activity.
task – an atomic unit of work that can be managed and that consumes resources.
goal – high-level principle used to guide the project.
functional requirement – an area of functionality that the system must have.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

29. Terminology (3)
Overview:
nonfunctional requirement – a constraint on the system.
notation – is a graphical or textual set of rules representing a model (e.g., UML)
method – a repeatable technique for solving a specific problem e.g. sorting algorithm
methodology – a collection of methods for solving a class of problems (e.g., Unified Software Development Process).
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

30. Software Processes Specification Development Validation Evolution
Overview:
Specification
requirements elicitation and analysis.
Development
systems design, detailed design (OO design), implementation.
Validation
validating system against requirements (testing).
Evolution
meet changing customer needs and error correction (maintenance).
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

31. Software Specification (1)
Overview:
Functionality of the software and constraints (non-functional requirements) on its operation must be defined.
Involves:
Requirements elicitation
The client and developers define the purpose of the system.
Output is a description of the system in terms of actors and uses cases.
Actors include roles such as end users and other computers the system needs.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

32. Software Specification (2)
Overview:
Uses cases are general sequences of events that describe all possible actions between actor and the system for a given piece of functionality.
Analysis
Objective: produce a model of the system that is correct, complete, consistent, unambiguous, realistic, and verifiable.
Developers transform the use cases into an object model that completely describes the system.
Model is checked for ambiguities and inconsistencies.
Output: Object model annotated with attributes, operations, and associations.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

33. Software Development (1)
Overview:
Producing the software that meets the specification.
System Design
Goals of the project are defined.
System decomposed into smaller subsystems (architectural model).
Strategies to build system identified
HW and SW platform, data management, control flow, and security.
Output: model describing subsystem decomposition and system strategies.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

34. Software Development (2)
Overview:
Object Design
Bridges the gap between analysis model and the strategies identified in the system design.
Includes:
Describing object and subsystem interfaces
Selecting off–the-shelf components
Restructure object model to attain design goals
e.g., extensibility, understandability, and required performance.
Output: detailed object model annotated with constraints and supporting documentation.
Implementation
Translation of the object model into source code.
No general process followed.
There are tools to assists the programmer such as CASE tools.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

35. Software Development Activities
Overview:
Introduction
Requirements Analysis
Evaluation
What is the problem?
SW Life Cycle
Motivation
Terminology
System Design
SW Processes
What is the solution?
Specification
Problem
Domain
Development
Validation
Implementation
Domain
Evolution
Object Design
What is the solution in a specific context?
SW Life Cycle
Cap. Maturity
Implementation
How is the solution constructed?

36. Software Validation (1)
Overview:
Ensures the software does what the customer want.
The software conforms to its specification and meets the expectations of the customer.
Validation: ‘Are we building the right product?’
Ensures the software meets the expectations of the customer.
Verification: ‘Are we building the product right?’
Ensures the software conforms to the specification.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

37. Software Validation (2)
Overview:
Techniques
Software inspections (static):
Analyze and check system representations (e.g., requirements documents, design diagrams, and program source code).
Software testing (dynamic):
Executing an implementation of the software with test data and examining the outputs against expected results.
V&V process establishes the existence of defects.
Debugging is a process that locates and corrects these defects.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

38. Software Evolution Software must evolve to meet the customer needs.
Overview:
Software must evolve to meet the customer needs.
Software maintenance is the process of changing a system after it has been delivered.
Reasons for maintenance
To repair faults.
To adapt the software to a different operating environment.
To add to or modify system’s functionality.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

39. Attributes of Good Software
Overview:
Maintainability
Ease of changing the software to meets the changing needs of the customer.
Dependability
Reliability, security and safety.
Efficiency
Responsiveness, processing time, and memory usage.
Usability
Appropriate user interface and adequate documentation.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Specification
Development
Validation
Evolution
SW Life Cycle
Cap. Maturity

40. Software Life Cycle Software life cycle modeling Software life cycle
Overview:
Software life cycle modeling
Attempt to deal with complexity and change.
Software life cycle
Set of activities and their relationships to each other to support the development of a software system .
Software development methodology
A collection of techniques for building models, which are applied across the software lifecycle.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

41. Software Life Cycle
Overview:
Software construction goes through a progression of states
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
Adulthood
Childhood
Retirement
Conception
SW Processes
SW Life Cycle
Cap. Maturity
Pre- Development
Post- Development
Development

42. Software Life Cycle Models
Overview:
Waterfall model and its problems
Pure Waterfall Model
V-Model
Iterative process models
Boehm’s Spiral Model
Unified Process Model
Entity-based models
Issue-based Development Model
Concurrent Development
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

43. Waterfall Model (1) The waterfall model
Overview:
The waterfall model
First described by Royce in 1970
There seem to be at least as many versions as there are authorities - perhaps more
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
Requirements
Definition
System and
software design
Implementation
and unit testing
Integration and
system testing
Operation and
maintenance
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

44. Waterfall Model (2)
Overview:
One or more documents are produced after each phase and “signed off”.
Points to note:
“Water does not flow up”.
it is difficult to change artifact produced in the previous phase.
This model should be used only when the requirements are well understood.
Reflects engineering practice.
Simple management model.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

45. From Waterfall to V Model
Overview:
Horizontal lines denote the information flow between activities at the same abstraction level.
Introduction
Evaluation
SW Life Cycle
Requirements
Specification
System design
Detailed Design
Implementation
Unit Test
System and
integration test
Acceptance
test
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

46. V Model
Overview:
Similar to pure waterfall model but makes explicit the dependency between development and verification activities.
The left half of the V represents development and the right half system validation.
Note the requirements specification includes systems reqs. analysis, reqs. elicitation, and reqs. analysis.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

47. Spiral Model (1) Basic Idea Two types: Advantages Disadvantages
Overview:
Basic Idea
develop initial implementation, expose it to user, and refine it until an adequate system is produced.
Two types:
Exploratory
Throw-away prototyping
Advantages
model used when problem is not clearly defined.
Disadvantages
Process not visible, systems are poorly constructed, may require special tools and techniques.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

48. Spiral Model (2) Design objectives, Evaluate alternatives,
alternatives, and constraints
Overview:
Evaluate alternatives,
identify and resolve risks
Introduction
Evaluation
Risk
analysis
SW Life Cycle
Risk
analysis
Motivation
Terminology
Risk
analysis
SW Processes
Prototype 3
Not shown
in detail
SW Life Cycle
Prototype 2
Prototype 1
Waterfall
Requirements
plan
Concept of
operation
S/w
Reqs.
Detailed
Design
Iterative
Sys.
Product
Design
Entity-Based
Development
Plan
Reqs.
Validation
Cap. Maturity
Code
Integration
Plan
Design
Validation
Unit Test
Integration &
Test
Acceptance
Test
Develop and verify
next level product
Plan next phase

49. Spiral Model (3)
Overview:
Tries to accommodate infrequent change during development.
Each round of the spiral involves:
Determine objectives
Specify constraints
Generate alternatives
Identify risks
Resolve risks
Develop and verify next level product
Plan
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

50. Incremental Development (1)
Overview:
Mills et al. 1980
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
Define outline
requirements
Assign requirements
to increments
Design system
architecture
Develop system
increment
Validate
Integrate
system
System incomplete
Final
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

51. Incremental Development (2)
Overview:
Software specification, design and implementation is broken down into a series of increments which are developed in turn.
Gives customers some opportunities to delay decisions on the detailed requirements of the system.
Services are identified and a priority allocated.
Each increment provides a subset of the system’s functionality.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

52. Incremental Development (3)
Overview:
Advantages:
Customers do not have to wait for the entire system.
Customers gain experience using early increments of the system.
Lowers the risk of overall project failure.
Most important system services receives the most testing.
Disadvantages:
May be difficult to map meaningful functionality into small increments.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

53. Extreme Programming
Overview:
The incremental approach has evolved to ‘extreme programming’ (Beck 1988).
Extreme programming:
Development and delivery of very small increments.
Customer involvement in the process.
Constant code improvement.
Egoless programming
Programs are regarded as group property!
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

54. Unified Software Development Process (1)
Overview:
Similar to Boehm’s spiral model.
A project consists of several cycles, each ends with the delivery of a product to the customer.
Each cycle consists of four phases:
Inception
Elaboration
Construction
Transition
Each phase consists of a number of iterations.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

55. Unified Software Development Process (2)
Overview:
Inception ends with
commitment from the project sponsor to go ahead.
Elaboration ends with
basic architecture of the system in place,
a plan for construction agreed,
all significant risks identified, and
major risks understood enough not to be too worried.
Construction ends with
a beta-release system.
Transition
is the process of introducing the system to it users.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

56. Unified Software Development Process (2)
Overview:
System
Development
Introduction
Evaluation
Analysis model
SW Life Cycle
specified by
Motivation
Terminology
realized by
Design model
SW Processes
SW Life Cycle
Use case
model
Waterfall
distributed by
Deployment model
Iterative
Entity-Based
implemented by
Cap. Maturity
Implementation
model
Requirements
captured as a
set of use cases.
verified by
Test model

57. Unified Software Development Process (3)
Overview:
Deployment model
physical communication links between hardware items.
relationships between physical machines and processes.
The models in the Unified Process are traceable
A model element can be traced to at least one element in an associated model.
Transition between models are seamless
we can tell in a foreseeable way how to get from an element in one model to one/more elements in an associated model.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
Entity-Based
Cap. Maturity

58. Issue-Based Development
Overview:
A system is described as a collection of issues
Issues are either closed or open.
Closed issues have a resolution.
Closed issues can be reopened (Iteration!).
The set of closed issues is the basis of the system model
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Waterfall
Iterative
I1:Open
I2:Closed
I3:Closed
A.I1:Open
A.I2:Open
SD.I1:Closed
SD.I2:Closed
SD.I3:Closed
Planning
Requirements Analysis
System Design
Entity-Based
Cap. Maturity

59. What to Choose? PT = Project Time, MTBC = Mean Time Between Change
Overview:
PT = Project Time, MTBC = Mean Time Between Change
Change rarely occurs (MTBC >> PT):
Waterfall Model
All issues in one phase are closed before proceeding to the next phase
Change occurs sometimes (MTBC = PT):
Boehm’s Spiral Model
Change occurring during a phase might lead to an iteration of a previous phase or cancellation of the project
“Change is constant” (MTBC << PT)
Issue-based Development (Concurrent Development Model)
Phases are never finished, they all run in parallel
Decision when to close an issue is up to management.
The set of closed issues form the basis for the system to be developed.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

60. IEEE 1074 Standard for Developing Life Cycle Processes
Overview:
Standard for Developing Life Cycle Processes
Describes the set of activities and processes that are mandatory for the development and maintenance of software.
Process is a set of activities that is performed towards a specific purpose.
Processes are grouped into higher abstractions called process groups.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

61. Software Processes Process Group Processes Project Management
Overview:
Process Group
Processes
Project Management
Project Initiation
Project Management and Control
Software Quality Management
Pre-development
Concept Exploration
System Allocation
Development
Requirements
Design
Implementation
Post-development
Installation
Operation and Support
Maintenance
Retirement
Integral Processes
Verification and Validation
Software Configuration Management
Document Development
Training
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

62. Capability Maturity Model (CMM)
Overview:
1. Initial Level
ad hoc, no feedback from user, black box.
2. Repeatable Level
Each project has a well-defined sw life cycle model.
3. Defined Level
A document sw life cycle model for all managerial and technical activities across the org. exists.
4. Managed Level
Metrics for activities and deliverables are defined.
5. Optimizing Level
Process allows feedback of information to change process itself.
Introduction
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity

63. State of the Software Industry in 1995
Overview:
Introduction
Maturity Level Frequency
1. Initial %
2. Repeatable %
3. Defined < 10%
4. Managed < 5%
5. Optimizing < 1%
Evaluation
SW Life Cycle
Motivation
Terminology
SW Processes
SW Life Cycle
Cap. Maturity
Source: Royce, Project Management, P. 364