SWD 392 - Software

Architecture and
Design
 SWD392

Overview of
Software Modeling
and Design
Method
Introduction
This chapter provides an overview of the software
modeling and design method, including requirements
modeling, analysis modeling, and design modeling. An
overview of the different kinds of software architectures
addressed in this textbook is given.
 Table of contents
Requirements,
00 Overview 03 analysis, and design
modeling

COMET use case– Designing

01 based software life 04 software
cycle architectures
Comparison of the
COMET life cycle
02 with other software 05 Summary
processes
 Overview
● COMET: Collaborative Object Modeling and
Architectural Design Method
● COMET is an iterative use case–driven and
object-oriented method
● COMET uses the UML notation
● COMET = UML + Method
 01
COMET use case–based
software life cycle
● The COMET use case–based software life cycle model
is a highly iterative software development
process based around the use case concept.
● In the requirements model: functional
requirements are described in terms of actors and
use cases. Each use case defines a sequence of
interactions between one or more actors and the
system.
● In the analysis model: the use case is realized to
describe the objects that participate in the use case
and their interactions.
The COMET method ties in the three phases of
requirements, analysis, and design modeling by means of
a use case-based approach
5.1.1 Requirements Modeling
During the
requirements
modeling phase, a
requirements model is
developed in which
the functional
requirements of the
system are described
in terms of actors
and use cases.
 5.1.2 Analysis Modeling
Analysis Modeling consists of
• Static Modeling
• Dynamic Modeling
 5.1.2 Analysis Modeling
Static Modeling
▪ Defines the structural
relationships among problem
domain classes.
▪ The classes and their
relationships are depicted on
class diagrams.
▪ Object structuring criteria are
used to determine the objects
to be considered for the
analysis model.
 5.1.2 Analysis Modeling
Dynamic Modeling
▪ Define statecharts for state dependent
control objects
▪ Defines how objects participate in use cases
using communication diagrams or sequence
diagrams
 5.1.3 Design Modeling
● In the design modeling phase, the software architecture
of the system is designed, in which the analysis model
is mapped to an operational environment.
● The analysis model, with its emphasis on the problem
domain, is mapped to the design model, with its
emphasis on the solution domain.
● For sequential systems, the emphasis is on the object-
oriented concepts of information hiding, classes, and
inheritance.
 5.1.4 Incremental Software
Construction
● After completion of the software architectural design, an
incremental software construction approach is taken.
● This approach is based on selecting a subset of the
system to be constructed for each increment.
● Incremental software construction consists of the
detailed design, coding, and unit testing of the classes
in the subset.
● This is a phased approach by which the software is
gradually constructed and integrated until the whole
system is built.
 5.1.5 Incremental Software
Integration
● During incremental software integration, the
integration testing of each software increment
is performed.
● The integration test for the increment is 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
 5.1.6 System Testing
● System testing includes the functional testing
of the system – namely, testing the system
against its functional requirements.
● Any software increment released to the
customer needs to go through the system
testing phase.
 02
Comparison of the COMET
life cycle with other
software processes
 5.2.1 Comparison of the COMET Life
Cycle with Unified Software
Development Process
● The USDP provides considerable detail about the life cycle
aspects and some detail about the method to be used.
● The workflows of the USDP are the requirements, analysis,
design, implementation, and test workflows.
● Each phase of the COMET life cycle corresponds to a workflow
of the USDP.
● The COMET incremental software construction activity
corresponds to the USDP implementation workflow.
 5.2.2 Comparison of the COMET
Life Cycle with the Spiral Model
● The COMET method can also be used with the spiral model
(Boehm 1988).
● During the project planning for a given cycle of the spiral
model, the project manager decides what specific technical
activity should be performed in the third quadrant, which is
the product development quadrant.
● The selected technical activity, such as requirements
modeling, analysis modeling, or design modeling, is then
performed in the third quadrant
● The risk analysis activity, performed in the second quadrant,
and cycle planning, performed in the fourth quadrant,
 03
Requirements, analysis,
and design modeling
● The UML notation supports requirements, analysis, and
design concepts.
● The COMET method described in this book separates
requirements activities, analysis activities, and design
activities.
● COMET differentiates analysis from design as follows:
1: Analysis is breaking down or decomposing the
problem so it is understood better;
2: Design is synthesizing or composing (putting
together) the solution.
 5.3.1 Activities in Requirements
Modeling
● In the requirements model, the system is considered as
a black box. The use case model is developed.
● Use case modeling. Define actors and black box use
cases.
▪ The use case descriptions are a behavioral view; the
relationships among the use cases give a structural
view.
▪ Addressing nonfunctional requirements is also
important at the requirements phase.
 5.3.2 Activities in Analysis
Modeling
● In the analysis model, the emphasis is on understanding
the problem; hence, the emphasis is on identifying the
problem domain objects and the information passed
between them.
● In the analysis model, the analysis of the problem
domain is considered. The activities are as follows:
▪ Static modeling
▪ Object structuring
▪ Dynamic interaction modeling
▪ Dynamic state machine modeling
 5.3.3 Activities in Design
Modeling
In the design model, the solution domain is considered. 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, in particular for sequential software
architectures.
▪ 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.
▪ Make decisions about the characteristics of messages, particularly whether
they are asynchronous or synchronous
 04
Designing software
architectures
• During software design modeling, design
decisions are made relating to the characteristics
of the software architecture.
▪Object-Oriented Software Architectures.
▪Client/Server Software Architectures.
▪Service-Oriented Architectures.
▪Distributed Component-Based Software
Architectures.
▪Real-Time Software Architectures.
▪Software Product Line Architectures.
 05
Summary
• This chapter described the COMET use case–based
software life cycle for the development of UML-based
object-oriented software applications.
• It compared the COMET life cycle with the USDP and the
spiral model, and described how the COMET method can be
used with either the USDP or the spiral model.
• The chapter then described the main activities of the COMET
method and concluded with a description of the steps in
using COMET. Each of the steps in the COMET method is
described in more detail in the subsequent chapters of this
textbook.
Thanks!