Object Oriented Analysis Process: Business Object Analysis:

INTRODUCTION:

Object-Oriented Analysis and Design (OOAD) is a software engineering methodology that involves using object-
oriented concepts to design and implement software systems. OOAD involves a number of techniques and
practices, including object-oriented programming, design patterns, UML diagrams, and use cases. Here are
some important aspects of OOAD:

Object-Oriented Programming: Object-oriented programming involves modeling real-world objects as software

objects, with properties and methods that represent the behavior of those objects. OOAD uses this approach to
design and implement software systems.

Design Patterns: Design patterns are reusable solutions to common problems in software design. OOAD uses
design patterns to help developers create more maintainable and efficient software systems.

UML Diagrams: Unified Modeling Language (UML) is a standardized notation for creating diagrams that
represent different aspects of a software system. OOAD uses UML diagrams to represent the different
components and interactions of a software system.

Use Cases: Use cases are a way of describing the different ways in which users interact with a software system.
OOAD uses use cases to help developers understand the requirements of a system and to design software
systems that meet those requirements.

There are several advantages to using OOAD in software engineering:

Reusability: OOAD emphasizes the use of reusable components and design patterns, which can save time and
effort in software development.

Scalability: OOAD can help developers design software systems that are scalable and can handle changes in user
demand and business requirements over time.

Maintainability: OOAD emphasizes modular design and can help developers create software systems that are
easier to maintain and update over time.

Flexibility: OOAD can help developers design software systems that are flexible and can adapt to changing
business requirements over time.

However, there are also some potential disadvantages to using OOAD:

Complexity: OOAD can be complex and may require significant expertise to implement effectively.

Time-consuming: OOAD can be a time-consuming process that involves significant upfront planning and
documentation.

Rigidity: Once a software system has been designed using OOAD, it can be difficult to make changes without
significant time and expense.

Cost: OOAD can be more expensive than other software engineering methodologies due to the upfront
planning and documentation required.

Overall, OOAD can be an effective approach to designing and implementing software systems, particularly for
complex or large-scale projects. However, it’s important to weigh the advantages and disadvantages carefully
before adopting this approach.

Object-Oriented Analysis (OOA) is the first technical activity performed as part of object-oriented software
engineering. OOA introduces new concepts to investigate a problem. It is based on a set of basic principles,
which are as follows-
The information domain is modeled.

Behavior is represented.

The function is described.

Data, functional, and behavioral models are divided to uncover greater detail.

Early models represent the essence of the problem, while later ones provide implementation details.

The above notes principles form the foundation for the OOA approach.

Object-Oriented Design (OOD): An analysis model created using object-oriented analysis is transformed by
object-oriented design into a design model that works as a plan for software creation. OOD results in a design
having several different levels of modularity i.e., The major system components are partitioned into subsystems
(a system-level “modular”), and data manipulation operations are encapsulated into objects (a modular form
that is the building block of an OO system.). In addition, OOD must specify some data organization of attributes
and a procedural description of each operation. Shows a design pyramid for object-oriented systems. It is
having the following four layers.

The Subsystem Layer : It represents the subsystem that enables software to achieve user requirements and
implement technical frameworks that meet user needs.

The Class and Object Layer : It represents the class hierarchies that enable the system to develop using
generalization and specialization. This layer also represents each object.

The Message Layer : It represents the design details that enable each object to communicate with its partners.
It establishes internal and external interfaces for the system.

The Responsibilities Layer : It represents the data structure and algorithmic design for all the attributes and
operations for each object.

The Object-Oriented design pyramid specifically emphasizes specific product or system design. Note, however,
that another design layer exists, which forms the base on which the pyramid rests. It focuses on the core layer
the design of the domain object, which plays an important role in building the infrastructure for the Object-
Oriented system by providing support for human/computer interface activities, task management.

Some of the terminologies that are often encountered while studying Object-Oriented Concepts include:

1. Attributes: a collection of data values that describe a class.

2. Class: encapsulates the data and procedural abstractions required to describe the content and behavior of
some real-world entity. In other words, A class is a generalized description that describes the collection of
similar objects.
3. Objects: instances of a specific class. Objects inherit a class’s attributes and operations.

4. Operations: also called methods and services, provide a representation of one of the behaviors of the class.

5. Subclass: specialization of the super class. A subclass can inherit both attributes and operations from a super
class.

6. Superclass: also called a base class, is a generalization of a set of classes that are related to it.

Advantages of OOAD:

Improved modularity: OOAD encourages the creation of small, reusable objects that can be combined to create
more complex systems, improving the modularity and maintainability of the software.

Better abstraction: OOAD provides a high-level, abstract representation of a software system, making it easier
to understand and maintain.

Improved reuse: OOAD encourages the reuse of objects and object-oriented design patterns, reducing the
amount of code that needs to be written and improving the quality and consistency of the software.

Improved communication: OOAD provides a common vocabulary and methodology for software developers,
improving communication and collaboration within teams.

Reusability: OOAD emphasizes the use of reusable components and design patterns, which can save time and
effort in software development by reducing the need to create new code from scratch.

Scalability: OOAD can help developers design software systems that are scalable and can handle changes in user
demand and business requirements over time.

Maintainability: OOAD emphasizes modular design and can help developers create software systems that are
easier to maintain and update over time.

Flexibility: OOAD can help developers design software systems that are flexible and can adapt to changing
business requirements over time.

Improved software quality: OOAD emphasizes the use of encapsulation, inheritance, and polymorphism, which
can lead to software systems that are more reliable, secure, and efficient.

Disadvantages of OOAD:

Complexity: OOAD can add complexity to a software system, as objects and their relationships must be carefully
modeled and managed.

Overhead: OOAD can result in additional overhead, as objects must be instantiated, managed, and interacted
with, which can slow down the performance of the software.

Steep learning curve: OOAD can have a steep learning curve for new software developers, as it requires a strong
understanding of OOP concepts and techniques.

Complexity: OOAD can be complex and may require significant expertise to implement effectively. It may be
difficult for novice developers to understand and apply OOAD principles.

Time-consuming: OOAD can be a time-consuming process that involves significant upfront planning and
documentation. This can lead to longer development times and higher costs.

Rigidity: Once a software system has been designed using OOAD, it can be difficult to make changes without
significant time and expense. This can be a disadvantage in rapidly changing environments where new
technologies or business requirements may require frequent changes to the system.

Cost: OOAD can be more expensive than other software engineering methodologies due to the upfront
planning and documentation required.
Object oriented design process & Design Axioms:

Design Analysis- What needs to be done

Objects discovered serve as the framework for designIdentified objects, attributes,
methods, associations must be designed for implementation as a data type expressed
in the implementation languageEmphasis from application domain to implementation
and computer concepts (user interface, access layer)Good design simplifies the
implementation and maintenance of a projectAxiomatic approach is to formalize the
design process and assist in establishing a scientific foundation for the OOD process

3 THE OOD PROCESSThe classes are viewed in the implementation point of view.
New classes and attributes can be added if requiredThe following activities are
followedApply design axioms to design classes, their attributes, methods,
associations, structures and protocols1.1 Refine and complete the static UML class
diagram1.1.1 Refine attributes.1.1.2 Design methods and protocols using UML activity
diagram1.1.3 Refine the associations1.1.4 Refine class hierarchy and design with
inheritance1.2 Iterate and refine again

4 Design the access layer

2.1 Create mirror classes for the access layer as business layer2.2 Identify access
layer class relationship2.3 Simplify classes and their relationships2.3.1 Avoid
redundant classes2.3.2 Delete classes that have only 1 or 2 methods. Try to add in
other classes2.4 Iterate and refine again

5 Design the view layer3.1 Design the macro level user interface, identifying view
layer objects3.2 Design the micro level user interface, which includes the following
activities3.2.1 Design the view layer objects by applying the design axioms and
corollaries3.2.2 Build the prototype of the view layer3.3 Test usability and user
satisfaction3.4 Iterate and refineIterate and refine the whole design. Reapply the
design axioms and repeat the preceding steps.

6 OOD AxiomsAxiom is a fundamental truth that is always observed to be valid and

for which there is no counterexample or exception. They cannot be proven or
derived.A theorem is a preposition that may not be self evident but can be proven by
accepted axioms. It is a law or principle. Theorem is valid if its referent axioms and
deductive steps are valid.

7 There are two axioms followed.

Axiom 1: The independence Axiom. (relationships between components)Maintain the
independence of componentsAxiom 2: The Information Axiom. ( complexity of
design)Minimize the information content of the design

8 Axiom 1: The independence Axiom

This Axiom states that, during the design process, as we go from requirements to a
system component, each component must satisfy that requirement without affecting
other requirementsE.g.., designing a refrigerator door with two requirements:Door
should provide access to the foodMinimal loss of energy on opening and closing it
(opening the door is independent of loss of energy)Requirements are coupledVertical
door – coupledThis can be designed by providing horizontally as like chest-type
freezers. Which satisfies both the requirements, without violating the first axiom

9 Axiom 2: The Information Axiom.

This Axiom is concerned with simplicityEach fact should be with a minimum amount of
complexity and maximum simplicity and straightforwardness.Minimal complexity
produces the most easily maintained and enhance applicationOOS- to use inheritance,
system’s built in classes to minimize complexity

10 COROLLARIESA Corollary is a proposition that follows from an axiom or another

proposition that has been provenCan be valid or invalid as theoremsThey are also
called as design rules.Derived from design axiomsUseful in making design decisions ,
since they are applied to actual situations more easily than original axioms

11 From the two axioms, the following corollaries are formed

Uncoupled design with less information contentHighly cohesive objects can improve
coupling because only a minimal amount of information need to be passed between
objectsSingle purposeEach Class must have a single, clearly defined purposeLarge
number of simple classesAllows reusabilityStrong mappingStrong association between
the analysis object and design objectStandardizationPromote standardization by
designing interchangeable components and reusing existing classes or
componentsDesign with inheritance

12 Corollary 1: Uncoupled design with less information content

The main goal here is to maximize objects cohesiveness among objects and software
components in-order to improve couplingCouplingThis is the measure of strength of
association established by a connection from one object or software component to
anotherChange to one component of the system should have minimal impact on the
other system.

13 Strong coupling among the objects complicates the system.

The degree of coupling is a function ofHow complicated the connection isWhether the
connection refers to the object itself or something inside itWhat is being sent or
receivedOOD – Interaction and Inheritance couplingInteraction Coupling involves the
amount and complexity of the messages between the componentsHence its better to
keep the messages simpleAlso reduce the number of messages sent & received by an
object(infrequent as possible)Inheritance coupling: coupling between super and sub
classesA subclass is coupled with its super class in terms of attributes and
methodsHigh inheritance coupling is desirableIf the sub class is overriding all of the
methods (low inheritance coupling)

14 Types of coupling among different objects or components

Content coupling – degree is very highCommon coupling – degree is highControl
coupling – degree is mediumStamp coupling – degree is lowData coupling – degree is
very low

15 Refers to the “single-purposeness” of an object

CohesionThis is the measure of strength of interaction within a single object or a
software componentRefers to the “single-purposeness” of an objectHighly cohesive
object have minimal coupling, because it needs only minimum amount of messages to
be passed between others.Types of cohesionMethod cohesionMethod should carry
only one functionMultiple functions is undesirableClass cohesionClass’s methods and
attributes must be highly cohesiveUsed by internal methods or derived
classesInheritance cohesionHow interrelated are the classes?Does specialization
portray or arbitrary?

16 Corollary 2: Single purpose

Each class must have a purposeDuring documentation, it should be possible to write
the purpose of the class within one or two sentenceIf it’s not possible, then think such
that, responsibilities can be divided into different classes.Method must provide only
one serviceKeep the classes simple

17 Corollary 3: Large number of simple classes

The classes created should be simple and more generalThis is useful for reusing the
classes for the futureIf the class is complex, try to divide the class, such that there
are large number of small classesFocus on reusability (higher productivity)

18 Corollary 4: Strong Mapping

This is used to link the classes analyzed during the analysis phase and the classes
designed during the design phase

19 Corollary 5: Standardization
The class libraries used in several object oriented programming must in a standard
form to enable reusability.Store it in repositoryProvide easy search through the
repository

20 Corollary 6: Designing with inheritance

When a class is implemented, it is necessary to determine its ancestors. What
attribute it will have, and what messages it will understand.Inheritance is used in-
order to minimize the amount of coding in the program

Access layer: Object store & persistence

DBMS:

A database
manageme
nt system
(DBMS) is
a collection
of related
data and
associated
programs
that
access,
manipulate
, protect
and
manage
data
A database
manageme
nt system
(DBMS) is
a collection
of related
data and
associated
programs
that
access,
manipulate
, protect
and
manage
data
A database
manageme
nt system
(DBMS) is
a collection
of related
data and
associated
programs
that
access,
manipulate
, protect
and
manage
data
A database
manageme
nt system
(DBMS) is
a collection
of related
data and
associated
programs
that
access,
manipulate
, protect
and
manage
data
A database management system(DBMS) is a collection of related data and associated programs that
access, manipulate, protect and manage data

What’s the purpose of DBMS

•The main purpose of a DBMS is toprovide a reliable, persistent datastorage facility,•and mechanism
for efficientand convenient data access andretrieval.
Persistence is defined as objectsthat outlive the programs whichcreated them.•Persistent object stores
do notsupport query or interactive userinterface facilities, as found in afully supported DBMS
orOODBMS.

Atkinson
et al.
describe
six broad
categories
for the
lifetime of
data:
– 1.
Transient
results to the
evaluation
of
expressions.
– 2.
Variables
involved in
procedure
activation
(parameters
and
variables
with a
localized
scope).
– 3. Global
variables
and
variables
that are
dynamically
allocated
Atkinson et al. describe six broadcategories for the lifetime of data:–1. Transient results to the
evaluationof expressions.–2. Variables involved in procedureactivation (parameters and variableswith
a localized scope).–3. Global variables and variablesthat are dynamically allocated
4. Data that exist between theexecutions of a program.–5. Data that exist between theversions of a
program.–6. Data that outlive a program
A DBMS is a set of programs thatenable the creation and maintenanceof a collection of related
data.•DBMS have a number of propertiesthat distinguish them from the file-based data management
approach
A database model is a collection oflogical constructs used to represent thedata structure and data
relationshipswithin the database.•Hierarchical Model–Network Model–Relational Model

The
hierarchica
l model
represents
data as a
single-
rooted tree
The hierarchical model representsdata as a single-rooted tree
A network database model is similarto a hierarchical database, with onedistinction.•Unlike the
hierarchical model, anetwork model's record can have morethan one parent

Of all the database models, therelational model has the simplest,most uniform structure and is themost
commercially widespread

Distributed Databases & Client Server computing:

In distributed databases portions ofthe database reside on differentnodes (computers) in the network
Client/server computing allowsobjects to be executed in differentmemory spaces or even
differentmachines
The calling module becomes the"client" (which requests a service),and the called module becomesthe
"server" (which provides theservice).
Client programs usually manage:•The user-interface•Validate data entered by the user•Dispatch
requests to serverprograms, and sometimes•Execute business logic
The Business layer contains all ofthe objects that represent thebusiness such as:–Order–Customer–
Line Item–Inventory, etc
A server process (program) fulfillsthe client request by performingthe task requested.•Server programs
generally receiverequests from client programs,execute database retrieval andupdates, manage
dataintegrity, and dispatchresponses to client requests

Multi Database systems

Designing Access layer classes

Macro level process

Micro Level Process

The purpose of view layer interface

Prototyping the user interface

Software Quality Assurance

Quality Assurance tests

Testing Strategies

Impact of Object orientation on testing

Test cases

Test plan

Continuous testing

System usability & measuring user satisfaction

Usability testing

User satisfaction test

A tool for analyzing user satisfaction

System usability & measuring user satisfaction Introduction

Usability testing