UNIT-III

DESIGN ENGINEERING
By
Mr.B.Narsimha Reddy
MTech(CSE),(PhD)
Associate Professor
Dept of CSE
what is software design?
• The process of creating software methods, functions, objects, and the
general structure and interaction of your code such that the resulting
functionality meets the needs of your users is known as software
design.
• Software design is a method that converts user requirements into a
suitable form for the programmer to employ in software coding and
implementation.
• It is concerned with converting
the client's requirements as
defined in the SRS (Software
Requirement Specification)
document into a form that can
be easily implemented using a
programming language.
Objectives of Software Design
• Correctness: Software design should be correct as per requirement.
• Completeness: The design should have all components like data
structures, modules, and external interfaces, etc.
• Efficiency: Resources should be used efficiently by the program.
• Flexibility: Able to modify on changing needs.
• Consistency: There should not be any inconsistency in the design.
• Maintainability: The design should be so simple so that it can be
easily maintainable by other designers.
• Content Covered:
• Software Design Process
• Design Quality Guidelines and Attributes
• Design Concepts
• Design Models
What is the design process?
• The design process is a tool that
helps you break down large
projects into smaller, easier-to
handle stages.
Software Design Process
• The design phase of software development deals with transforming
the customer requirements as described in the SRS documents into a
form implementable using a programming language.
• The software design process is a systematic approach to creating a
blueprint for the software.
• It translates user requirements into a structured design that
developers can implement.
• The goal is reliable, maintainable, and scalable software that meets
objectives.
• The software design process can be divided into the following three
levels of phases of design:
• 1. Interface Design
• 2. Architectural Design
• 3. Detailed Design
• Interface Design (how users interact),
• Architectural Design (system components and their relationships),
• Detailed Design (internal elements, data structures, and algorithms
within components).
Interface Design

• Focus: Defines how different

components of a system interact with
each other.
• Includes:
• User Interface (UI): How users interact
with the system (e.g., screens, buttons).
• System Interfaces: Interaction between
hardware, software modules,
databases, etc.
• Goal: Ensure seamless and consistent
communication between users and
system components.
Architectural Design

• Focus: High-level structure of the entire

system.
• Includes:
• Defining software components/modules.
• How components interact
(communication patterns).
• Selection of architectural styles (e.g.,
MVC ,layered, microservices, client-
server).
• Goal: Establish a blueprint for system
structure that meets performance,
scalability, and reliability needs.
Detailed Design

• Focus: Internal logic and structure

of individual modules/components.
• Includes:
• Algorithms.
• Data structures.
• Pseudocode or flowcharts.
• Class diagrams in object-oriented
systems.
• Goal: Provide enough detail for
developers to implement each
component accurately.
Why is Software Design
important?
• Software design ensures maintainability, scalability, efficiency, and
security.
• It simplifies debugging, enhances collaboration, reduces costs,
improves user experience and making software development more
structured, reliable, and future-proof.
Software Quality Guidelines
1. A design is generated using the recognizable architectural styles and compose a good
design characteristic of components and it is implemented in evolutionary manner for
testing.
2. A design of the software must be modular i.e the software must be logically
partitioned into elements.
3. In design, the representation of data , architecture, interface and components should
be distinct.
4. A design must carry appropriate data structure and recognizable data patterns.
5. Design components must show the independent functional characteristic.
6. A design creates an interface that reduce the complexity of connections between the
components.
7. A design must be derived using the repeatable method.
8. The notations should be use in design which can effectively communicates its meaning.
Software Quality Attributes
• In software engineering, FURPS
stands for
• Functionality,
• Usability,
• Reliability,
• Performance,
• Supportability,
a model used to classify and assess
software quality attributes, both
functional and non-functional.
• Functionality:
• This encompasses the features and capabilities of the software,
including its suitability, accuracy, interoperability, and security.
• Usability:
• This focuses on how easy to use, considering factors like learnability,
understandability, and operability.
• Reliability:
• This refers to the software's ability to perform consistently and
predictably, including its error-free operation and ability to recover
from failures.
• Performance:
• This evaluates the software's efficiency and responsiveness, including
processing speed, response time, and resource consumption.
• Supportability:
• This refers to the ease with which the software can be maintained,
adapted, and extended, including attributes like testability, flexibility,
and installability.
 Design concepts
in
Software Engineering
• The set of fundamental software design concepts are as follows:
1. Abstraction

• In software design, abstraction simplifies complex systems by

focusing on essential details and hiding implementation complexities,
enabling easier management and maintainability.
• Real-world: When you drive a car, you don't need to know how the
engine works to start it or how the brakes function to stop.
• Software: Similarly, in software, you might use a function or method
without knowing the exact implementation details.
2. Architecture

• In software engineering,
• architecture design defines
the high-level structure,
components, and interactions of
a software system, acting as a
blueprint for its development
and ensuring it meets functional
and non-functional
requirements.
3. Patterns

• A design pattern describes a

design structure and that
structure solves a particular
design problem in a specified
content.
• Provides reusable solutions to
common design problems.
• Examples:
• Singleton, Factory, Observer
patterns.
4. Modularity

• A software is separately divided

into name and addressable
components.
• Sometime they are called as
modules which integrate to
satisfy the problem
requirements.
• Modularity is the single attribute
of a software that permits a
program to be managed easily.
5. Information hiding

• Modules must be specified and

designed so that the information
like algorithm and data
presented in a module is not
accessible for other modules not
requiring that information.
Key Differences:

Feature Abstraction Information Hiding

Focus Simplifying complexity, showing Protecting data and
essentials implementation details

Goal User-friendliness, maintainability Security, modularity, and

reduced coupling

Mechanism Hiding implementation details Restricting access to

internal components

Example User interface of a software Private variables in a class

application

Techniques Abstract classes, interfaces, Access modifiers,

modules encapsulation
6. Functional independence

• The functional independence is the concept of

separation and related to the concept of
modularity, abstraction and information hiding.
• The functional independence is accessed using
two criteria i.e Cohesion and coupling.
• Cohesion
• Cohesion is an extension of the information hiding
concept.
• A cohesive module performs a single task and it
requires a small interaction with the other
components in other parts of the program.
• Coupling
• Coupling is an indication of interconnection
between modules in a structure of software.
7. Refinement

• Refinement is a top-down design

approach.
• It is a process of elaboration.
• A program is established for
refining levels of procedural
details.
• A hierarchy is established by
decomposing a statement of
function in a stepwise manner till
the programming language
statement are reached.
8. Refactoring

• Refactoring is the process of

improving the internal structure
of existing code without
changing its external behavior.
• It enhances code readability,
maintainability, and
performance.
Design classes

• The model of software is defined as a set of design classes.

• Every class describes the elements of problem domain and that focus
on features of the problem which are user visible.
What are the various tools used for creating
Software Design?

• Many tools can be used for designing software.

• The top 6 most effective and commonly used tools are:-

• Draw.io
• Jira
• Mockflow
• Sketch
• Marvel
• Zeplin
 Design Modeling
in
Software Engineering
• A Design Model in software
engineering is a structured
framework that helps in
translating software
requirements into a blueprint for
implementation.
• It represents different aspects of
the system, including its
architecture, components,
interfaces, and interactions.
• Design modeling in software engineering refers to the process of
creating abstract representations of a software system's structure,
behavior, and interactions to guide the development process.
• It plays a critical role in bridging the gap between system
requirements and implementation.
What is Design Modeling?

Design modeling is part of the

software design phase of the
Software Development Life Cycle
(SDLC).
It helps:
• Visualize the system architecture.
• Understand system components
and their interactions.
• Serve as a blueprint for
developers.
Benefits of Design Modeling

• Design models help in:

• Communication: Facilitating communication among developers,
stakeholders, and clients.
• Early Problem Detection: Identifying potential issues and conflicts in
the design phase.
• Improved Maintainability: Creating a well-structured and organized
system that is easier to maintain and modify.
• Reduced Development Time: By having a clear design, developers can
focus on implementation rather than constantly re-designing.
Key Elements of Design Modeling

1.Data Design:
• Defines how data is organized,
structured, and stored within the
system.
• Data Structures: Choosing
appropriate data structures (e.g.,
arrays, linked lists, trees) for
efficient data handling.
• Data Relationships: Modeling
relationships between different data
entities (e.g., one-to-one, one-to-
many).
2. Architectural Design:

• Defines the overall structure

and organization of the software
system.
• System Components: Identifying
key modules, subsystems, and
their interactions.
• Architectural Styles: Choosing
appropriate architectural styles
(e.g., layered, microservices)
based on project requirements.
3.Interface Design:

• Defines how users interact with

the software system.
• User Interface (UI): Designing
the visual layout, controls, and
navigation of the user interface.
• API Design: Designing the
interfaces that allow different
software components to
communicate with each other.
4.Component-Level Design:

• Focuses on the design of

individual software components.
• Component Functionality:
Defining the purpose and
functionality of each
component.
• Component Interfaces: Defining
the interfaces that allow
components to interact with
each other.
5.Deployment-Level Design:

• Defines how the software will be

deployed and run in the target
environment.
• Hardware and Software
Requirements: Identifying the
hardware and software
requirements for running the
application.
• Network Configuration: Defining
the network configuration for the
application.
Summary Table

Design Element Description Common Diagrams

Architectural Design Overall system structure. Component, Deployment
How data is structured ER Diagram, DFD, Class
Data Design and flows. Diagram
Interaction with Use Case Diagram,
Interface Design users/external systems. Wireframes
Internal logic of
Component-Level Design components/modules. Class Diagram, Flowcharts
Dynamic behavior and State, Sequence, Activity
Behavioural Design control flow. Diagrams
Creating an Architectural Design
• Introduction
• The software needs the architectural design to represents the design
of software.
• IEEE defines architectural design as
• “the process of defining a collection of hardware and software
components and their interfaces to establish the framework for the
development of a computer system.”
Key points of software architecture

• High-level design: It focuses on the big picture, making decisions about the overall
structure and how different parts of the system will work together.
• Component identification and selection: Determining the necessary components
and their functionalities.
• Interaction patterns: Defining how different parts of the system will communicate
and exchange data.
• Quality attributes: Considerations for things like scalability, performance, security,
and maintainability.
• System organization: Arranging components in a way that facilitates understanding
and collaboration among developers.
• Evolution and future needs: Planning for how the system might evolve and adapt to
future requirements.
Why is software architecture
important?
• Improved system quality: A well-designed architecture leads to a more
robust, maintainable, and scalable system.
• Reduced development costs: A clear architecture can streamline
development, making it easier to build and modify the system.
• Enhanced communication: It provides a shared understanding of the
system's structure for all stakeholders, including developers, project
managers, and clients.
• Facilitates early risk identification: Analyzing the architecture can help
identify potential design flaws and risks early in the development process.
• Supports future development: A well-defined architecture makes it easier
to add new features, integrate with other systems, and adapt to changing
business needs.
 Data Design
• Data design in software engineering refers to the process of
organizing and structuring data in a way that supports efficient
software development, data storage, retrieval, and maintenance.

• 1. Data Design at the Architectural Level

• 2. Data Design at the Component Level
Data Design at the Architectural
Level
• At the architectural level, data design focuses on defining how data is
organized, accessed, and managed across the entire software
system.
• Architecture-level data design concerns high-level data
models, data flows, and the relationships between
different data stores.
• Focus:
• High-level data models, data flows, and relationships between data stores.
• Purpose:
• Ensures data integrity, consistency, and accessibility across the entire
system.
• Example:
• Defining the overall structure of a database, including tables, relationships,
and indexes, to support the application's requirements.
• Benefits:
• Minimizes errors in software design and database development, improves
database performance, and facilitates data mapping across the
organization.
Data Design at the Component
Level
• Component-level design, on the other hand, involves specifying the
data structures, algorithms, and interfaces needed for each
component to process data efficiently.
• Focus:
• High-level data models, data flows, and relationships between data stores.
• Purpose:
• Ensures data integrity, consistency, and accessibility across the entire
system.
• Example:
• Defining the overall structure of a database, including tables, relationships,
and indexes, to support the application's requirements.
• Benefits:
• Minimizes errors in software design and database development, improves
database performance, and facilitates data mapping across the
organization.
Architectural styles and
patterns
• In Software Engineering, architectural styles and architectural
patterns are fundamental concepts that describe the high-level
structure of a software system.
• They define how components interact, how data flows, and how
responsibilities are distributed.
• Architectural style and pattern are two distinct
concepts in software design, each influencing how a
system is structured at different levels of abstraction.
• Architectural styles define the overall structure and
organization of a system,
• while architectural patterns describe reusable solutions
to recurring problems within that structure.
Architectural Styles
• An architectural style is a broad classification of system architecture
that provides a general pattern for organizing system components.
• Common Architectural Styles
• Layered Architecture
• Client-Server Architecture
• Event-Driven Architecture (EDA)
• Microservices Architecture
• Service-Oriented Architecture (SOA)
• Pipe and Filter Architecture
Layered Architecture

• Structure: Divides the system

into layers (e.g., Presentation,
Business Logic, Data).
• Example: OSI Model, Java EE
Applications.
• Advantage: Separation of
concerns.
Client-Server Architecture

• Structure: Clients request

services from servers.
• Example: Web browsers (clients)
and web servers.
• Advantage: Centralized control,
scalable.
Event-Driven Architecture (EDA)

• Structure: Components
communicate via events.
• Example: GUI applications, IoT
systems.
• Advantage: Loose coupling,
asynchronous communication.
Microservices Architecture

• Structure: System is composed

of small, independently
deployable services.
• Example: Netflix, Amazon.
• Advantage: Scalability,
maintainability.
Service-Oriented Architecture
(SOA)
• Structure: Uses services for
communication between
components.
• Example: Web services using
SOAP(Simple Object Access
Protocol) or
REST(Representational
State Transfer).
• Advantage: Interoperability
across platforms.
Pipe and Filter Architecture

• Structure: Data is passed

through a sequence of
processing elements (filters).
• Example: UNIX shell, compilers.
• Advantage: Easy to understand
and reuse.
 Architectural Patterns

• An architectural pattern is a reusable solution to a common

architectural problem in a given context.
• It often includes best practices and specific design approaches.
Common Architectural Patterns:
• Layered Pattern (n-tier architecture)
• Client-Server Pattern
• MVC (Model-View-Controller)
• Microservices Pattern
• Event-Driven Pattern
• Microkernel (Plug-in) Pattern
• Broker Pattern
• Pipe and Filter Pattern
• Blackboard Pattern
Layered Pattern (n-tier
architecture)
• Structure: Organizes the system
into layers where each layer has
a specific role (e.g., Presentation,
Business, Data).
• Use Case: Enterprise
applications, desktop and web
applications.
• Advantages:
• Separation of concerns
• Easy to maintain and test
Client-Server Pattern

• Structure: Divides the system

into two parts – clients
(requesters) and servers
(providers).
• Use Case: Web applications,
email, file sharing.
• Advantages:
• Centralized control
• Easier updates and security
management
 Model-View-Controller (MVC)

• Structure:
• Model: Handles data and business logic
• View: UI layer
• Controller: Handles input and updates
model/view
• Use Case: Web frameworks (Django,
Ruby on Rails, ASP.NET MVC).
Microservices Pattern

• Structure: Application is composed of small, loosely coupled services

that communicate via APIs.
• Use Case: Scalable web apps (Netflix, Amazon).
Event-Driven Pattern

• Structure: Components communicate through event messages.

• Types:
• Broker (mediator-based)
• Event Bus (publisher-subscriber)
• Use Case: Real-time systems, IoT, user interfaces.
Microkernel (Plug-in) Pattern

• Structure: Core system with

plug-in modules for extended
functionality.
• Use Case: IDEs (Eclipse),
browsers.
• Advantages:
• Flexibility
• Easy extensibility
Broker Pattern

• Structure: A broker mediates

communication between clients
and servers.
• Use Case: Distributed systems
(CORBA, RMI).
Pipe and Filter Pattern

• Structure: Components (filters)

transform data as it passes
through pipes.
• Use Case: Compiler design, UNIX
pipelines.
Blackboard Pattern

• Structure: All components

interact through a common data
structure (blackboard).
• Use Case: AI, speech recognition
systems.
• Advantages:
• Supports complex and dynamic
problem solving
Architectural Styles vs
Architectural Patterns
Feature Architectural Style Architectural Pattern
A broad structural framework that defines A solution to a common architectural
Definition
the organization of a software system. problem in a specific context.

Structure and organization of components Reusable design solutions and best

Focus
and their interactions. practices.
More concrete and implementation-
Level More abstract and generic.
oriented.
Solves specific architectural
Purpose Provides a general structure or guideline.
problems.
Offers detailed approaches to solve
Flexibility Offers a conceptual template (not strict).
specific design challenges.
Layered, Client-Server, Event-Driven,
Examples MVC, Microkernel, Broker, Blackboard
Microservices
Like choosing a building layout style (e.g., Like choosing a design pattern for a
Analogy
bungalow, apartment). room (e.g., modular kitchen layout).
Thank you