Вы находитесь на странице: 1из 28

CT015-3-2 Design Methods

Object Oriented Software Life Cycle


Learning objectives

• At the end of this lecture, you should be


able to :
– Explain and identify COMET
– Explain comparison of the COMET with
other Software Processes

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 2 of 18
COMET
(Collaborative Object Modeling
and Architectural Design Method)
• An iterative use case–driven and
object-oriented method that
specifically addresses - requirements,
analysis, and design modeling phases
of the software development life cycle.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 3 of 18
COMET Phases:
Requirements modeling
• A requirements model is developed in which the
functional requirements of the system are described in
terms of actors and use cases.
• A narrative description of each use case is developed.
• In this phase, user inputs and active participation are
essential
• Throwaway prototypes can help to clarify the
requirements.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 4 of 18
Activities in Requirements Modeling

• Use-case modeling
– Define actors/stakeholder needs
– Define black-box use cases for analysis

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 5 of 18
COMET Phases:
Analysis modeling
• Static and dynamic models of the system are developed.
– Static Models
• Defines the structural relationships among problem domain
classes which depicted on class diagrams. Object
structuring criteria are used to determine the objects to be
considered for the analysis model.
– Dynamic Models
• The use cases from the requirements model are realized to
show the objects that participate in each use case and how
they interact with each other which are depicted on either
communication diagrams or sequence diagrams. In the
dynamic model, state-dependent objects are defined using
statecharts.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 6 of 18
Activities in Analysis Modeling

– Static Modeling
• Classes are defined in terms of their attributes as well as their
relationship with other classes.
• Operations are defined in the design model
– Object Structuring
• Determine the objects that participate in each use case.
– Dynamic Interaction Modeling
• Communication/sequence diagrams are developed to show how objects
communicate with each other to execute the use case.
– Dynamic State Machine Modeling
• State-dependent view of the system is defined using hierachical
statecharts.

* Important note: Other design issues deferred to design phase, e.g.


active/passive, sync/async, operations invoked
CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 7 of 18
COMET Phases:
Design modeling
• The software architecture of the system is designed in
which the analysis model mapped to an operational
environment.
• Subsystems are identified and structured
- Emphasis is on designing distributed subsystems as configurable
components that communicate with each other via messages.
• For sequential systems: the emphasis is on the object-
oriented concepts of information hiding, classes, and
inheritance.
• For concurrent systems: such as real-time, client/server,
and distributed applications, it is necessary to consider
concurrent tasking concepts in addition to object-oriented
concepts.
CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 8 of 18
Activities in Design Modeling

• During this phase, the analysis model is mapped to


a concurrent design model:
- Integrate the object communication model.
- Make decisions about subsystem structure and interfaces.
- Make decisions about what software architectural and design
patterns to use in the software architecture.
- Make decisions about class interfaces. For each subsystem,
design the information hiding classes (passive classes).
Design the operations of each class and the parameters of
each operation.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 9 of 18
Activities in Design Modeling

- Make decisions about how to structure the distributed


application into distributed subsystems, in which
subsystems are designed as configurable components, and
define the message communication interfaces between the
components.
- Make decisions about the characteristics of objects,
particularly whether they are active or passive. For each
subsystem, structure the system into concurrent tasks (active
objects).
- Make decisions about the characteristics of messages,
particularly whether they are asynchronous or synchronous
(with or without reply).

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 10 of 18
COMET Phases:
Incremental Software Construction
• The software subsystems are incrementally constructed and
integrated into incremental prototypes.
• Select subset of system based on use cases
• This phase consists of:-
- detailed design
- coding
- unit testing
• Gradually constructed and integrated until the whole system
is built.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 11 of 18
COMET Phases:
Incremental Software Integration
• The integration testing of each software increment is
performed based on the use cases selected for the
increment.
• Integration testing is a form of white box testing, in
which the interfaces between the objects that participate
in each use case are tested.
• If significant problems are detected in the software
increment, iteration through the requirements modeling,
analysis modeling, and design modeling phases might
be necessary.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 12 of 18
COMET Phases:
System testing
• System testing includes the functional testing of
the system
- testing the system against its functional
requirements.
• This testing is black box testing and is based on
the black box use cases
• Any software increment released to the
customer needs to go through the system testing
phase.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 13 of 18
Comparison Of The Comet
Life Cycle With Other Software
Processes

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 14 of 18
Unified Software Development
Process (USDP)
• Also known as RUP - trademark name for
IBM
• A use case–driven software process
that uses the UML notation.
• Consists of 5 workflows and 4 phases and
is iterative.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 15 of 18
USDP

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 16 of 18
COMET vs USDP

• Directly compatible with COMET


– The first three phases even have same
names
• USDP’s Testing phase is broken into
COMET’s Incremental Integration and
System Testing phases
– These activities should be performed by
separate teams.
• Incremental Integration -> Development Team
• System Testing -> Testing Team
CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 17 of 18
Spiral Model

• A risk-driven process model


• Each cycle of the spiral model iterates
through these four quadrants and the
number of cycles is project-specific.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 18 of 18
Spiral Model

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 19 of 18
COMET vs Spiral

• The COMET method can also be used with the spiral model.
• Project manager decides what specific technical activity
should be performed in the third quadrant.
 1st Quadrant : Objective identification
 2nd Quadrant : Risk analysis
 3rd Quadrant : Product development
- Requirement Modeling
- Analysis Modeling
- Design Modeling
 4th Quadrant : Cycle planning

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 20 of 18
Review

• What is COMET?
• List all the phases in COMET.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 21 of 18
Exercise

• What is carried out during requirements


modeling?
a) Functional requirements of the system are
described in terms of functions, inputs, and outputs.
b) Functional requirements of the system are
described in terms of actors and use cases.
c) Functional requirements of the system are
described textually.
d) Functional requirements of the system are
determined by interviewing users.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 22 of 18
Exercise

• What is carried out during analysis


modeling?
a) Developing use case models.
b) Developing data flow and entity-relationship
diagrams.
c) Developing static and dynamic models.
d) Developing software architectures.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 23 of 18
Exercise

• What is carried out during design


modeling?
a) Developing use case models.
b) Developing data flow and entity-relationship
diagrams.
c) Developing static and dynamic models.
d) Developing software architectures.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 24 of 18
Exercise

• What is carried out during incremental


software construction?
a) Detailed design and coding of the classes in a
subset of the system.
b) Detailed design, coding, and unit testing of the
classes in a subset of the system.
c) Coding and unit testing of the classes in a subset of
the system.
d) Unit and integration testing of the classes in a
subset of the system.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 25 of 18
Exercise

• What is carried out during incremental


software integration?
a) Implementation of the classes in each software
increment.
b) Unit testing of the classes in each software
increment.
c) Integration testing of the classes in each software
increment.
d) System testing of the classes in each software
increment.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 26 of 18
Exercise

• What is carried out during system testing?


a) White box testing.
b) Black box testing.
c) Unit testing.
d) Integration testing.

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 27 of 18
Q&A

CT015-3-2 Design Methods Object Oriented Software Life Cycle – Part 1 Slide 28 of 18