UNIT-3

1. Software Design Basic Concept of Software Design,

2. Architectural Design,
3. Low Level Design:
3.1 Modularization,
3.2 Design Structure Charts,
3.3 Pseudo Codes,
3.4 Flow Charts,
3.5 Coupling and Cohesion Measures,
4. Design Strategies:
4.1 Function Oriented Design,
4.2 Object Oriented Design,
4.3 Top-Down and Bottom-Up Design.
5. Software Measurement and Metrics:
6. Various Size Oriented Measures:
6.1 Halestead‟s Software Science,
6.2 Function Point (FP) Based Measures,
6.3 Cyclomatic Complexity Measures: Control Flow Graphs

--------------------------------------------------------------------------------------------------------------------------------

Software Design:

 Software design is a process of converting user requirement into some suitable

form which helps the programmer in software coding and implementation.
 During the software design phase main objective is to convert the user
requirements in SRS is to be converted into design document(SDD-Software
Design Document).
 Objectives:
1. Correctness: A good design should be correct, that means it should
implements all functionality of the system.
2. Efficiency: A good software design should address cost, time and
optimization issues.
3. Understandability: Good software should be understandable. It should be
divided into multiple modules.
 4. Completeness: A design should have all component like data structure
modules and external interfaces.
5. Maintainability: Changes can easily amendable in software system.

Architectural Design:

 The process of defining software and hardware component and their

interfaces to establish a framework for the development of software
system. (IEEE Definition).
 Architectural Styles:
1. Data Centered Architecture:
Data remain at the center of the architecture and all the components frequently
access the data and performs the update, delete and insert operation.
2. Data Flow Architectures:
This kind of architecture is used when input data is to be transformed into
output through series of computational and manipulative components.
3. Call and Return Architecture:
 It is used to create program that is easy to scale and modify.

1. High Level System Design(HLD):

 It is the overall system design.
 It includes the brief description of the software: like database
design, design description, services, relationship among module
etc.
 It is known as macro level detail design
2. Low Level Design:
 LLD is like details of HLD.
 It includes detail description of each and every module.
 It is known as micro level detail design.
  Basically designing is two-part iterative process the first part is the
conceptual design that tells the customer what the will do.
 The second part is the technical design in which system builder understand
the actual hardware and software needed to solve the customer’s problem.

Modularization:

 It is a technique to develop to divide the software

system into multiple discrete and independent modules.

Coupling:

 Coupling measures the degree of interdependence between the

modules.
 Good Software will have low coupling.

 Data Coupling: If the coupling between the module is based on the

fact that they communicate only by passing the data.
 Stamp Coupling: Whole data structure is passed from one module to
other.
  Control Coupling: If the modules are communicating by passing the
control information.
 External Coupling: If the modules depend on completely different
modules external to the software being developed.
 Common Coupling: There is global data accessible to all modules,
changes to this data means tracing back which modules have made
changes to the modules.
 Content Coupling: One Modules can modify the data of the other
module.

Cohesion: Cohesion is degree to which elements of the module are functionally

related.

Cohesion is measure of the functional strength of the module.

 Good Software design will have high cohesion.


 Types of Cohesion:
1. Functional Cohesion: Every essential element to perform a task is
contained within the module.
2. Sequential Cohesion: An element output some data which becomes to
the other element.
3. Communication Cohesion: Two or more elements of the module
operate on the same input data and contribute toward the same output
data.
4. Procedural Cohesion: Elements of the modules ensures the procedural
execution of the series of task.
5. Temporal Cohesion: Task which occurs at the same time span are put
within one module.
6. Logical Cohesion: All the elements of the module should be logically
related.
7. Coincidental Cohesion: Elements are not related, this is accidental or
worst kind of cohesion.

1. Function Oriented Design:

 In Function design the system is consists of many sub-
system called function.
 The design mechanism the divides the whole system into
smaller functions. This module can share information
among them by means of information passing.
 When one function is called it changes the whole state of
the system which is not acceptable by the other modules.
2. Object Oriented Design:
 Object: All entities involved in the design process.
 Classes: A class is generalized description of object. An
object is instance of class.
 Encapsulation
 Inheritance
  Polymorphism


Software Metrics:
A software metric is a measure of software characteristics which are
measurable or countable. Software metrics are valuable for many
reasons, including measuring software performance, planning work
items, measuring productivity, and many other uses.

Classification of Software Metrics

Software metrics can be classified into two types as follows:

1. Product Metrics: These are the measures of various characteristics of the software

product. The two important software characteristics are:

1. Size and complexity of software.

2. Quality and reliability of software.

These metrics can be computed for different stages of SDLC.

3. Process Metrics: These are the measures of various characteristics of the

software development process. For example, the efficiency of fault detection.
 They are used to measure the characteristics of methods, techniques, and tools
that are used for developing software.

Types of Metrics
Internal metrics: Internal metrics are the metrics used for measuring properties that are
viewed to be of greater importance to a software developer. For example, Lines of Code
(LOC) measure.

External metrics: External metrics are the metrics used for measuring properties that
are viewed to be of greater importance to the user, e.g., portability, reliability,
functionality, usability, etc.

Hybrid metrics: Hybrid metrics are the metrics that combine product, process, and
resource metrics. For example, cost per FP where FP stands for Function Point Metric.

Project metrics: Project metrics are the metrics used by the project manager to check
the project's progress. Data from the past projects are used to collect various metrics,
like time and cost; these estimates are used as a base of new software. Note that as the
project proceeds, the project manager will check its progress from time-to-time and will
compare the effort, cost, and time with the original effort, cost and time. Also
understand that these metrics are used to decrease the development costs, time efforts
and risks. The project quality can also be improved. As quality improves, the number of
errors and time, as well as cost required, is also reduced.

Size Oriented Metrics

LOC Metrics
It is one of the earliest and simpler metrics for calculating the size of the computer
program. It is generally used in calculating and comparing the productivity of
programmers. 

Following are the points regarding LOC measures:

1. In size-oriented metrics, LOC is considered to be the normalization value.

2. It is an older method that was developed when FORTRAN and COBOL programming
were very popular
3. Productivity is defined as KLOC / EFFORT, where effort is measured in person-months
 4. Size-oriented metrics depend on the programming language used
5. As productivity depends on KLOC, so assembly language code will have more
productivity.
6. LOC method of measurement does not apply to projects that deal with visual
(GUI-based) programming. As already explained, Graphical User Interfaces (GUIs)
use forms basically. LOC metric is not applicable here.
7. These metrics are not universally accepted

Advantages of LOC
1. Simple to measure

Disadvantage of LOC
1. It is defined on the code. For example, it cannot measure the size of the
specification.
2. It characterizes only one specific view of size, namely length, it takes no account
of functionality or complexity
3. Bad software design may cause an excessive line of code
4. It is language dependent
5. Users cannot easily understand it

Halstead's Software Metrics

According to Halstead's "A computer program is an implementation of an algorithm
considered to be a collection of tokens which can be classified as either operators or
operand.

Token Count
In these metrics, a computer program is considered to be a collection of tokens, which
may be classified as either operators or operands. All software science metrics can be
defined in terms of these basic symbols. These symbols are called as a token.

The basic measures are

n1=countof unique operators.

n2= count of unique operands.
N1= count of total occurrences of operators.
N2 = count of total occurrence of operands.

In terms of the total tokens used, the size of the program can be expressed as N = N1 +
N2
 Functional Point Analysis:

 The basic and primary purpose of the functional point analysis is to measure and
provide the software application functional size to the client, customer, and the
stakeholder on their request.
 Various function used in application can be categorized under following:

 The efforts required to develop software program depends upon what software
does.
 FP is programming language independent.


 Unadjusted Function Point(UFP)
 Adjusted Function Point(AFP)
 Complexity Adjustment Factor(CAF)
 AFP=UFP x CAF
 CAF
 CAF-Complexity adjustment factor Calculation The complexity adjustment factor (CAF) is based
on 14 general system characteristics (GSC's) that rate the general functionality of the application
being counted. Each characteristic has associated descriptions that help determine the degrees
of influence of the characteristics. The degrees of influence range on a scale of zero to five, from
no influence to strong influence. The table 3 is intended to provide an overview of each GSC.