UNIT IV

DESIGN ENGINEERING
Software Design Concepts
Contents

1. Software Design Concepts

2. Architectural Design
 Software Design
● Software design is the process of transforming user requirements into a
structured and suitable format that helps programmers in coding and
implementation.
● It acts as a blueprint for software development.
● It is carried out by software design engineers.
● This process ensures that the software architecture, components, and
interactions are well-defined to meet functional and non-functional
requirements efficiently.
Why is it important?
● Design allows you to model the system or product that is to be built.
● This model can be assessed for quality and improved before code is
generated, tests are conducted, and end users become involved in large
numbers.
● Design is the place where software quality is established.
What are the steps?
Design depicts the software in a number of different ways.
● First, the architecture of the system or product must be represented.
● Then, the interfaces that connect the software to end users, to other
systems and devices, and to its own constituent components are
modeled.
● Finally, the software components that are used to construct the system
are designed.
Software Design Process
The software design process can be divided into the following 3 levels of phases of
design:

1. Interface Design: It focused on interaction between the system and the users
devices. Scenario & Behavioral based diagram used. Not focus on internal
structure.

2. Architectural Design: It focused on major components of a system their

responsibilities. properties. interfaces, relationships and interactions between
them. Class based & flow based diagram used.

3. Detailed Design: It focused on internal elements of all major system

components, their properties, relationships, processing , algorithms and data
structures.
Software Quality Guidelines and Attributes
● The goal of any software design is to produce high quality software.
● In order to evaluate quality of software there should be some predefined
rules or criteria that need to be used to assess the software product. Such
criteria serve as characteristics for good design.
The quality guidelines are as follows -
1. The design architecture should be created using following -
● The design should be created using architectural styles and patterns.
● Each component of design should posses good design characteristics.
● The implementation of design should be evolutionary, so that testing
can be performed at each phase of implementation.
2. In the design the data, architecture, interfaces and components should be
clearly represented.
3. The design should be modular. That means the subsystems in the design should
be logically partitioned.
4. The data structure should be appropriately chosen for the design of specific
problem.
5. The components should be used in the design so that functional independence
can be achieved in the design.
6. Using the information obtained in software requirement analysis the design
should be created.
7. The interfaces in the design should be such that the complexity between the
connected components of the system gets reduced. Similarly interface of the
System with external interface should be simplified one.
8. Every design of the software system should convey its meaning appropriately
and effectively.
Software Quality Attributes
Hewlett-Packard developed a set of software quality attributes that has been given
the acronym FURPS—functionality, usability, reliability, performance, and
supportability.

1. Functionality: It evaluates the feature set , capabilities of the program,

security of the overall system.

2. Usability: It is accessed by considering the factors such as User experience

aspects like ease of use, UI design, and accessibility.

3. Reliability: It is evaluated by measuring parameters like frequency and

security of failure, output result accuracy , recovery from failure and
program predictability.
4. Performance: It is measured by considering processing speed. response time.
Resource consumption, throughput and efficiency.

5. Supportability: It combines the ability to extend the program (extensibility),

adaptability, serviceability—these three attributes represent a more common
term, maintainability.
Software Design Concepts

● The software design concept simply means the idea or principle behind the
design.

● It describes how you plan to solve the problem of designing software.

● It also shows the logic or thinking behind how you will design software.

● The software design concept for developing the right software provides a
supporting and essential structure or model.
Software Design Concepts
1. Abstraction

2. Architecture

3. Design Patterns

4. Modularity

5. Information Hiding

6. Functional Independence

7. Refinement

8. Refactoring

9. Object-Oriented Design Concept

 1. Abstraction
● Abstraction is used to hide background details or unnecessary
implementation about the data.
● So that users see only required information.

Type 1: Procedural Abstraction:

● There is collections of subprograms.
● One is hidden group another is visible group of functionalities. Example:

Type 2: Data Abstraction:

● Collections of data that describe data objects.
● Show representation data & hide manipulation data.
● Examples: Data Structure Programs directly used Push(), Pop(), Top() and
Empty() methods.
2. Architecture
● The architecture is the structure of program modules where they interact with
each other in a specialized way.

➢ Structural Properties: Architectural design represent different types of

components, modules, objects & relationship between these.

➢ Extra-Functional Properties: How design architecture achieve

requirements of Performance. Capacity Reliability Security, Adaptability &
other System Characteristics.

➢ Families of related systems: The architectural design should draw

repeatable patterns. They have ability to reuse repeatable blocks.
3. Design Patterns
● Brad Appleton defines a design pattern -
A design pattern describes a design structure that solves a particular design problem
within a specific context and amid "forces" that may have an impact on the manner in
which the pattern is applied and used.
● Design pattern is to provide a description that enables a designer to determine
(1) whether the pattern is applicable to the current work,
(2) whether the pattern can be reused .
(3) whether the pattern can serve as a guide for
developing a similar, but functionally or structurally
different pattern.
4. Modularity
● Modularity simply means dividing the system or project into smaller parts to
reduce the complexity of the system or project.

● After developing the modules, they are

integrated together to meet the software
requirements.

● Modularizing a design helps to effective

development. accommodate changes easily
conduct testing. debugging efficiently and
conduct maintenance work easily.
5. Information Hiding
6. Functional Independence
7. Refinement
8. Refactoring
● Refactoring is the process of changing the internal software system in a wav
that it does not change the external behavior of the code still improves its
internal structure.

● When software is refactored the existing design is examined for redundancy,

unused design elements. unnecessary design algorithms. poorly constructed
data. inappropriate data structure or any other design failure that can be
corrected for better design.
9. Object Oriented Design Concepts
About Coupling
• The coupling is the degree of interdependence or number of relations between
software modules.
• Two modules that are tightly coupled are strongly dependent on each other.
• However, two modules that are loosely coupled are not much dependent on each
other.
• A good design is the one that has Low coupling.
• High coupling generates more errors because they shared large number of data.
Types of Coupling
Type 3: External Coupling

● When two modules share an externally import data format, communication

protocols or device interface.
● This is related to communication to external tools and devices.

Type 4: Control Coupling

● Control coupling handle functional flow between software modules.

● Example: Module l- Set Flag = I then only Module 2 perform action.
About Cohesion
● Cohesion defines to the degree to which the elements of a module belong
together or interrelated.
● Thus, cohesion measures the strength of relationships between pieces of
functionality within a given module.
● A good software design will have high cohesion.
Types of Cohesion
Type 4: Procedural Cohesion

● All parts of a procedure execute in particular sequence of steps for achieving

goal.
● Example: Calling one function to another function, Loop statements, Reading
record etc.
Type 5: Communicational Cohesion

● If all the elements of a moåule are working on the same input & output data
and are accessing that data through the same data structures.
● Example: Update record in the database and send it to the printer.
Type 6: Sequence Cohesion
● Output of one element treats as an input to the other elements inside the
same module.
● Example: Enter the numbers -> Perform Addition of that numbers -> Display
Addition.
Type 7: Function Cohesion
● If a single module aims to perform all the similar types of functionalities
through its different elements.
● The purpose of functional cohesion is single minded, high, strong and focused.
● Example: Railway Reservation System
Coupling VS Cohesion
Coupling Cohesion
Coupling represents how the modules are In cohesion, the cohesive module performs only
connected with other modules or with the one thing.
outside world.

With coupling interface complexity is decided. With cohesion, data hiding can be done.

The goal of coupling is to achieve lowest The goal of cohesion is to achieve high
coupling. cohesion.

Various types of couplings are - Data coupling, Various types of cohesion are - Coincidental
Control coupling, Common coupling and cohesion, Logical cohesion, Temporal cohesion,
Content coupling. Procedural cohesion and Communicational
cohesion.

When modules are highly cohesive, a When the modules are loosely coupled, it
high quality software is built. results in a high quality software.
Cohesion: Think of a library 📚—each section contains
related books (high cohesion).

Coupling: Think of classrooms 🏫—each should function

independently, but if all depend on the same projector (high
coupling), failure affects everyone.
Design Classes
Design classes are defined as the classes that describe some elements of problem
domain, focus on various aspects of problem from user's point of view.

The goals of design classes is :

1. To refine the analysis classes by providing the detail design, so that further
implementation can be done easily.

2. To create new set of classes for implementing the infrastructure of the

software. There are five different types of design classes.
1. User Interface Class : The user interface class defines all the abstractions that
are necessary for Human Computer Interface(HCI). The user interface classes is
basically a visual representation of the HCI.
2. Business Domain Class : Business domain classes are the refinement of
analysis classes. These classes identify the attributes and services that are needed
to implement some elements of business domain.
3. Process Class : Process class implement lower level business abstractions used
by the business domain.
4. Persistent Class : These classes represent the data store such as databases
which will be retained as it is even after the execution of the software.
5. System Class : These classes are responsible for software management and
control functions that are used for system operation.
The Design Model and Elements
• The design phase of software development, transforming the customer requirements as

described in the SRS documents into design forms.

• Designing a model is an important phase and is a multi-process that represent the data
structure. program structure. interface characteristic and procedural details.

➢ There are four types of design elements / models

1. Data Design Element / Model

2. User Interface Design Element / Model

3. Architectural Design Element / Model

4. Component Level Design Element / Model

The design model can be viewed in two different dimensions

● (Horizontally) The process dimension indicates the evolution of the

parts of the design model as each design task is executed

● (Vertically) The abstraction dimension represents the level of detail

as each element of the analysis model is transformed into the design
model and then iteratively refined
• The design model has the following layered elements
1. Data/class design
2. Architectural design
3. Interface design
4. Component-level design
5. Deployment-level design
DATA/CLASS DESIGN
● Data/class design creates a model of data and objects that is represented at a
high level of abstraction.
● The initial data/class design focuses on creating a conceptual model of data and
objects.
● It represents relationships, attributes, and structure without worrying about
implementation details.
● This data model is refined into progressively more implementation-specific
representations that can be processed by computer based systems.
● The abstract data model is gradually transformed into a more detailed and
implementation-specific form.
● It evolves through multiple stages, incorporating data structures, database
schemas, and object-oriented programming (OOP) elements.
Architectural Design Elements
● Architectural design for the software is equivalent to the 'floor plan' of
a house
● Depicts the overall layout of the software
● Derived from three sources-
○ Information about the application domain
○ Specific requirements elements
○ Architectural styles and patterns
 Interface Design Elements
• Tells how information flows into and out of the system and how it is
communicated among the components defined as part of the architecture
• Includes the user interface, external interfaces, and internal interfaces
Component Level Design Elements
● The component level design elements describe the internal details of the
component.
● In component level design all the local data objects, required data structures
and algorithmic details and procedural details are exposed.
● In a context of object-oriented software engineering, a component shown in a
UML diagram.
Deployment Level Design Elements
• Indicates how software functionality and subsystems will be allocated within the
physical computing environment that will support the software.
Architectural Design
● Software architecture design represent the structure of data and program
component that are required to build a computer based system.
● It is just a blueprint.
● The software architecture of a program or computing system is the overall
structure of the system which comprise
• The software components

• The externally visible properties of those components

• The relationships among the components

Why is Architecture Important ?
● Representations of software architecture are an enabler for communication
between all parties (stakeholders) interested in the development of a
computer-based system.

● Some early design decisions can be taken using software architecture and
hence system performance and operations remain under control. Early
decisions impact the entire software lifecycle, affecting future changes and
enhancements.

● The software architecture gives a clear cut idea about the computer based system
which is to be built.
 ARCHITECTURAL STYLES
The architectural model or style is a pattern for creating the system architecture
for given problem. However, most of the large systems are heterogeneous and do
not follow single architectural style.

The commonly used architectural styles are

1. Data centered architectures.

2. Data flow architectures.

3. Layered architectures.

4. Object oriented architectures.

5. Call and return architectures.

Data-centered architectures.
● A Data-Centered Architecture organizes software around a centralized data
repository.
● Components interact with data rather than directly with each other.
● The main objective is to ensure data integrity, consistency, and efficiency.
● Data-centered architectures promote integrability [Bas03]. That is, existing
components can be changed and new client components added to the
architecture without concern about other clients (because the client components
operate independently).
Data-centered architectures.
Data-flow architectures.
● This architecture is applied when input data are to be transformed through a
series of computational or manipulative components into output data.
● A pipe-and-filter pattern (Figure 9.2) has a set of components, called filters,
connected by pipes that transmit data from one component to the next.
● These filters work independently without a bothering about the working of
neighbouring filter.
● If the data flow degenerates into a single line of transforms, it is termed batch
sequential. This structure accepts a batch of data and then applies a series of
sequential components (filters) to transform it.
Call and Return Architecture
● The Call and Return Architecture is a hierarchical architecture where
components (modules) communicate by calling and returning functions or
procedures.

🔹 Working Mechanism:
1⃣ The system is divided into multiple modules (functions or procedures).
2⃣ A main module (or function) calls sub-modules to perform specific tasks.
3⃣ These sub-modules may further call other modules, creating a hierarchical
structure.
4⃣ After execution, control is returned to the calling module.

🔹 Types of Call and Return Architecture:

✔ Main-Subroutine Architecture – Traditional procedural programming (e.g., C,
Pascal).
✔ Remote Procedure Call (RPC) Architecture – Used in distributed systems.
Layered Architecture
Object Oriented Architecture
● In this architecture the system is decomposed into number of interacting objects.
● These objects encapsulate data and the corresponding operations that must be
applied to manipulate the data.
● The object oriented decomposition is concerned with identifying objects classes, their
attributes and the corresponding operations.
● Communication and coordination between components are accomplished via
message passing.