Unit II

Functional Modeling: Data flow diagram, specifying operations, constraints, a sample

functional model.OMT (object modeling techniques) methodologies, examples and case studies
to demonstrate methodologies, comparisons of methodologies, SA/SD, JSD.

Function Modeling:
The functional model shows how values are computed for sequencing, decision, or object
structure, the function model shows which values depend on which other values and the
function that relate them

Data flow diagram

Data flow diagrams were proposed by Larry Constantine, the original developer of structured
design,[3]based on Martin and Estrin's "data flow graph" model of computation.

A data flow diagram (DFD) is a graphical representation of the "flow" of data through an information
system, modeling its processaspects. Often they are a preliminary step used to create an overview of the
system which can later be elaborated. [2] DFDs can also be used for the visualization of data
processing (structured design).

A DFD shows what kinds of information will be input to and output from the system, where the data will
come from and go to, and where the data will be stored. It does not show information about the timing of
processes, or information about whether processes will operate in sequence or in parallel (which is shown
on a flowchart).

The data flow diagram contains following elements:

Processes

Data flows
Actors

Data stores

Nested DFD :

A data flow diagram may be broken into smaller functional units , a

specifying operations

constraints

A sample functional model

OMT Methodologies
The object-modeling technique (OMT) is an object modeling language for software modeling and
designing. It was developed around 1991 by Rumbaugh, Blaha, Premerlani, Eddy and Lorensen as a
method to develop object-oriented systems and to supportobject-oriented programming.Describes Object
model or static structure of the system.
OMT was developed as an approach to software development. The purposes of modeling according to
Rumbaugh are:
 testing physical entities before building them (simulation),
 communication with customers,
 visualization (alternative presentation of information), and
 reduction of complexity.
OMT has proposed three main types of models:

 Object model: The object model represents the static and most stable phenomena in the modeled
domain. Main concepts are classes and associations with attributes and operations. Aggregation and
generalization (with multiple inheritance) are predefined relationships.
 Dynamic model: The dynamic model represents a state/transition view on the model. Main concepts
are states, transitions between states, and events to trigger transitions. Actions can be modeled as
occurring within states. Generalization and aggregation (concur-rency) are predefined relationships.
 Functional model: The functional model handles the process perspective of the model, corresponding
roughly to data flow diagrams. Main concepts are process, data store, data flow, and actors.
OMT is a predecessor of the Unified Modeling Language (UML). Many OMT modeling elements are
common to UML.
The entire OMT software development process has four phases: Analysis, system design,
object design, and implementation of the software. Most of the modeling is performed in the
analysis phase. The recommended method incorporates the following activities (Rumbaugh et
al., 1991:261ff):

1. Develop a Problem Statement.

2. Build an Object Model:
1. Identify object classes.
2. Develop a data dictionary for classes, attributes, and associations.
3. Add associations between classes.
4. Add attributes for objects and links.
5. Organize and simplify object classes using inheritance.
6. Test access paths using scenarios and iterate the above steps as necessary.
7. Group classes into modules, based on close coupling and related function.
3. Build a Dynamic Model:
1. Prepare scenarios of typical interaction sequences.
2. Identify events between objects and prepare an event trace for each scenario.
3. Prepare an event flow diagram for the system.
4. Develop a state diagram for each class that has important dynamic behavior.
5. Check for consistency and completeness of events shared among the state
diagrams.
4. Build a Functional Model:
1. Identify input and output values.
2. Use data flow diagrams as needed to show functional dependencies.
3. Describe what each function does.
4. Identify constraints.
5. Specify optimization criteria.
5. Verify, iterate, and refine the three models:
1. Add most important operations to the object model.
2. Verify that classes, associations, attributes and operations are consistent and
complete, check with problem statement.
 3. Iterate steps to complete the analysis.

The OMT methodology is a methodology of software engineering. Which is a process for the
organized production of software , using a collection of predefined techniques and notational
conventions. The step of software production are usually organized into a life cycle (called
SDLC) consisting of several phases as following:

 Problem formation
 Analysis
 Design
 Implementation
 Testing
 Maintenance and enhancement

This OMT methodology supports the entire software life cycle.

There are four main phases of OMT methodology:

1. Analysis phase
2. System design phase
3. Object design phase
4. Implementation phase

1. Analysis Phase: Analysis phase takes problem statement and produce object , dynamic
and function model for a system. The analysis phase accepts input as a problem statement
describing the problem to be solved along with a conceptual overview of the proposed system.
The output from the analysis phase is a formal model that captures the following aspects of the
system.
a. Objects and their relationship(object model)
b. Dynamic flow of control (dynamic model)
c. Functional transformation of data subject to constraints (Functional
model)
a. Object modeling: the information gathered for object model from :
i. Problem statement
ii. User interview
iii. Expert knowledge of application platform
 iv. General knowledge of the real world.

The following steps are performed in constructing an object model

i. Identity object and class

ii. Prepare a data dictionary
iii. Identify association (including aggregation) between objects.
iv. Identify attributes of objects and links
v. Organize and simplify object classes using inheritance.
vi. Verify that access paths exist for likely queries.
vii. Iterate and refine the model.
viii. Group classes into modules.
b. Dynamic modeling:

c. Function model: It shows the functional derivation of values , when they computer.

The following steps are performed in constructing a function model:

- Indentify i/p and o/p values.

- Build data flow diagram showing functional dependencies.
- Describe functions .
- Identify constraints.
- Specify optimization.
- Criteria.

2- System Design Phase: During the design phase, decisions are made about how the
problem will be solved. First at a high level, then an increasingly detailed level. The system design is the
first design stage in which the basic approach for solving the problem is selected.

The system architecture is the overall organization of the system into components called subsystems.

1. Organize the system into subsystem.

2. Identify concurrency inherent in the problem.
3. Allocate subsystem to processors and tasks.
4. Choose an approach for management of data stores.
5. Handle access to global resources.
6. Choose the implementation of control in software.
7. Handle boundary conditions.
8. Set trade-off priorities.

3- Object Design Phase: the object design phase determines page 113
4- Implementation Phase:

Comparisons of methodologies
There are several popular software engineering approaches for developing the software. And
the most of the approaches and based on the data flow diagrams. Two approaches to compare
with OMT , which are :

1. Structured analysis / structured Design (SA/SD)

2. Jackson Structured Design(JSD)
1. Comparisons with SA/SD: SA/SD methodology contains much common features as
OMT both methodology use similar modeling constructs and support the three
orthogonal views of a system. It includes a variety of notations for formally specifying
software.
a. In SA/SD approache the the functional model dominates , the dynamic model
is next important , and the object model least important.
b. SA/SD organizes a system around procedures , while OMT organizes a
system around real world objects.
c. SA/SD is useful for problems where functions are more important and
complex than data.
d. An SA/SD design has a clearly – designed system boundary.

2. Comparisons with JSD: JSD has a different life cycle.

JSD is the approaches where JSD does not discuss between analysis and design
pahses.

JSD software development consists of six steps:

i. entity action
ii. ii entity structure
iii. iii. Initial model
iv. iv. Function

v. system timing . vi implementation

JSD approach uses graphical models but JSD is less graphically oriented then
SA/SD and OMT.
JSD approach is complex.
 JSD places more emphasis on action and less on attributes that OMT.

JSD
Jackson system development (JSD) is a linear software development methodology developed
by Michael A. Jackson and John Cameron in the 1980s.

Principles of operation
Three basic principles of operation of JSD is that:

 Development must start with describing and modelling the real world, rather than specifying or
structuring the function performed by the system. A system made using JSD method performs the
simulation of the real world before any direct attention is paid to function or purpose of the system.
 An adequate model of a time-ordered world must itself be time-ordered. Main aim is to map progress
in the real world on progress in the system that models it.
 The way of implementing the system is based on transformation of specification into efficient set of
processes. These processes should be designed in such a manner that it would be possible to run
them on available software and hardware.