UNIT 3 Design Engineering

3.1 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 can be divided into the following
three levels of phases of design:
1. Interface Design
2. Architectural Design
3. Detailed Design
Elements of a System:
1. Architecture – This is the conceptual model that defines the structure, behavior,
and views of a system. We can use flowcharts to represent and illustrate the
architecture.
2. Modules – These are components that handle one specific task in a system. A
combination of the modules makes up the system.
3. Components – This provides a particular function or group of related functions.
They are made up of modules.
4. Interfaces – This is the shared boundary across which the components of a
system exchange information and relate.
5. Data – This is the management of the information and data flow.
Interface Design: Interface design is the specification of the interaction between a system
and its environment. this phase proceeds at a high level of abstraction with respect to the
inner workings of the system i.e, during interface design, the internal of the systems are
completely ignored and the system is treated as a black box. Attention is focused on the
dialogue between the target system and the users, devices, and other systems with which it
interacts. The design problem statement produced during the problem analysis step should
identify the people, other systems, and devices which are collectively called agents.
Interface design should include the following details:
 Precise description of events in the environment, or messages from agents to
which the system must respond.
 Precise description of the events or messages that the system must produce.
 Specification of the data, and the formats of the data coming into and going out
of the system.
 Specification of the ordering and timing relationships between incoming events
or messages, and outgoing events or outputs.
Architectural Design: Architectural design is the specification of the major components of
a system, their responsibilities, properties, interfaces, and the relationships and interactions
between them. In architectural design, the overall structure of the system is chosen, but the
internal details of major components are ignored. Issues in architectural design includes:
 Gross decomposition of the systems into major components.
 Allocation of functional responsibilities to components.
 Component Interfaces
 Component scaling and performance properties, resource consumption
properties, reliability properties, and so forth.
 Communication and interaction between components.
The architectural design adds important details ignored during the interface design. Design
of the internals of the major components is ignored until the last phase of the
design. Detailed Design: Design is the specification of the internal elements of all major
system components, their properties, relationships, processing, and often their algorithms
and the data structures. The detailed design may include:
 Decomposition of major system components into program units.
 Allocation of functional responsibilities to units.
 User interfaces
 Unit states and state changes
 Data and control interaction between units
 Data packaging and implementation, including issues of scope and visibility of
program elements
 Algorithms and data structures

3.2 Design Quality

Design quality in software engineering refers to the attributes and characteristics of a

software system's design that impact its overall quality, maintainability, and effectiveness in
meeting its intended purpose. These attributes are crucial for creating software that is reliable,
maintainable, scalable, and adaptable. While I can't provide diagrams directly, I can describe
the key aspects of design quality, and you can create a diagram based on this information.
1. Modularity and Decomposition:

 Modularity refers to breaking down a software system into smaller, self-contained

modules or components.

 Each module should have a well-defined purpose, a clear interface, and minimal
dependencies on other modules.

 A diagram representing modularity might show the main system as a box with smaller
boxes representing modules, connected by arrows indicating dependencies or interactions.

2. Cohesion:

 Cohesion measures how closely related the functionality within a module or component
is.

 High cohesion means that the module has a single, well-defined purpose, reducing
complexity and making it easier to understand and maintain.

 A diagram could depict cohesion by showing a module with various internal components
tightly connected to a single task.
3. Coupling:

 Coupling measures the interdependence between modules or components.

 Low coupling indicates that modules are loosely connected and changes in one module
have minimal impact on others.

 In a diagram, low coupling can be represented by arrows connecting modules with few
connections.

4. Abstraction:

 Abstraction involves simplifying complex systems by hiding unnecessary details and

exposing only essential information.

 Diagrams can represent abstraction by using high-level views that hide implementation
details, such as class diagrams showing only class names and their relationships.

5. Reusability:

 Reusable design elements enable the same components or modules to be used in multiple
parts of the software or in different projects.

 A diagram could depict reusability by showing how common components are used in
different parts of the system.

6. Scalability:

 Scalable designs can accommodate growth in data, users, or functionality without

significant performance degradation or architectural changes.

 Diagrams might show how the system can be expanded by adding additional components
or modules.

7. Maintainability:

 Maintainable designs are easy to understand and modify without introducing errors.

 Diagrams can represent maintainability by showing clear relationships between modules,

making it evident how changes in one area may impact others.

8. Separation of Concerns:

 Separation of concerns involves isolating different aspects of the software (e.g., user
interface, business logic, data storage) into distinct modules or layers.

 Diagrams might illustrate this by depicting the various layers and how they interact, such
as in an architecture diagram.

9. Compliance with Design Patterns:

 Design patterns are established solutions to common design problems.

 Diagrams can demonstrate compliance with design patterns by showing how specific
patterns are used in the system's architecture or code.

10. Adherence to Standards:

 Design quality often requires following industry standards and best practices.

 Diagrams can highlight the use of standard conventions, interfaces, and protocols in the
system.

Remember that design quality is not a one-time effort but an ongoing consideration
throughout the software development process. Creating diagrams to visualize the design can
be a helpful tool in evaluating and communicating design quality to stakeholders. Different
types of diagrams, such as UML diagrams (e.g., class diagrams, component diagrams, and
sequence diagrams), can be used to represent various aspects of design quality.

3.3 Design Concept

Software Design Concepts:

Concepts are defined as a principal idea or invention that comes into our mind or in
thought to understand something. 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, the logic, or thinking behind how you will design software. It
allows the software engineer to create the model of the system or software or
product that is to be developed or built. The software design concept provides a
supporting and essential structure or model for developing the right software. There
are many concepts of software design and some of them are given below:
The following points should be considered while designing Software:

1. Abstraction- hide Irrelevant data

Abstraction simply means to hide the details to reduce complexity and
increases efficiency or quality. Different levels of Abstraction are
necessary and must be applied at each stage of the design process so that
any error that is present can be removed to increase the efficiency of the
software solution and to refine the software solution. The solution should
be described in broad ways that cover a wide range of different things at a
higher level of abstraction and a more detailed description of a solution of
software should be given at the lower level of abstraction.
2. Modularity- subdivide the system
Modularity simply means dividing the system or project into smaller parts
to reduce the complexity of the system or project. In the same way,
modularity in design means subdividing a system into smaller parts so that
these parts can be created independently and then use these parts in
different systems to perform different functions. It is necessary to divide
the software into components known as modules because nowadays there
are different software available like Monolithic software that is hard to
grasp for software engineers. So, modularity in design has now become a
trend and is also important. If the system contains fewer components then
it would mean the system is complex which requires a lot of effort (cost)
but if we are able to divide the system into components then the cost
would be small.
3. Architecture- design a structure of something
Architecture simply means a technique to design a structure of something.
Architecture in designing software is a concept that focuses on various
 elements and the data of the structure. These components interact with
each other and use the data of the structure in architecture.
4. Refinement- removes impurities
Refinement simply means to refine something to remove any impurities if
present and increase the quality. The refinement concept of software
design is actually a process of developing or presenting the software or
system in a detailed manner that means to elaborate a system or software.
Refinement is very necessary to find out any error if present and then to
reduce it.
5. Pattern- a repeated form
The pattern simply means a repeated form or design in which the same
shape is repeated several times to form a pattern. The pattern in the design
process means the repetition of a solution to a common recurring problem
within a certain context.
6. Information Hiding- hide the information
Information hiding simply means to hide the information so that it cannot
be accessed by an unwanted party. In software design, information hiding
is achieved by designing the modules in a manner that the information
gathered or contained in one module is hidden and can’t be accessed by
any other modules.
7. Refactoring- reconstruct something
Refactoring simply means reconstructing something in such a way that it
does not affect the behavior of any other features. Refactoring in software
design means reconstructing the design to reduce complexity and simplify
it without affecting the behavior or its functions. Fowler has defined
refactoring as “the process of changing a software system in a way that it
won’t affect the behavior of the design and improves the internal
structure”.

Different levels of Software Design:

There are three different levels of software design. They are:

1. Architectural Design:
The architecture of a system can be viewed as the overall structure of the system
& the way in which structure provides conceptual integrity of the system. The
architectural design identifies the software as a system with many components
interacting with each other. At this level, the designers get the idea of the
proposed solution domain.

2. Preliminary or high-level design:

Here the problem is decomposed into a set of modules, the control relationship
among various modules identified, and also the interfaces among various
modules are identified. The outcome of this stage is called the program
architecture. Design representation techniques used in this stage are structure
chart and UML.

3. Detailed design:
Once the high-level design is complete, a detailed design is undertaken. In
 detailed design, each module is examined carefully to design the data structure
and algorithms. The stage outcome is documented in the form of a module
specification document.

3.4 Design Model

Design modeling in software engineering represents the features of the software that helps

engineer to develop it effectively, the architecture, the user interface, and the component level

detail. Design modelling provides a variety of different views of the system like architecture

plan for home or building. Different methods like data-driven, pattern-driven, or object-

oriented methods are used for constructing the design model. All these methods use set of

design principles for designing a model.

 Data design: It represents the data objects and their interrelationship in an entity-

relationship diagram. Entity-relationship consists of information required for each

 entity or data objects as well as it shows the relationship between these objects. It

shows the structure of the data in terms of the tables. It shows three type of

relationship – One to one, one to many, and many to many. In one to one relation, one

entity is connected to another entity. In one many relation, one Entity is connected to

more than one entity. un many to many relations one entity is connected to more than

one entity as well as other entity also connected with first entity using more than one

entity.

 Architectural design: It defines the relationship between major structural elements of

the software. It is about decomposing the system into interacting components. It is

expressed as a block diagram defining an overview of the system structure – features

of the components and how these components communicate with each other to share

data. It defines the structure and properties of the component that are involved in the

system and also the inter-relationship among these components.

 User Interfaces design: It represents how the Software communicates with the user

i.e. the behavior of the system. It refers to the product where user interact with

controls or displays of the product. For example, Military, vehicles, aircraft, audio

equipment, computer peripherals are the areas where user interface design is

implemented. UI design becomes efficient only after performing usability testing.

This is done to test what works and what does not work as expected. Only after

making the repair, the product is said to have an optimized interface.

 Component level design: It transforms the structural elements of the software

architecture into a procedural description of software components. It is a perfect way

to share a large amount of data. Components need not be concerned with how data is

managed at a centralized level i.e. components need not worry about issues like

backup and security of the data.

Principles of Design Model

 Design must be traceable to the analysis model:

Analysis model represents the information, functions, and behavior of the system. Design

model translates all these things into architecture – a set of subsystems that implement major

functions and a set of component kevel design that are the realization of Analysis classes.

This implies that design model must be traceable to the analysis model.

 Always consider architecture of the system to be built:

Software architecture is the skeleton of the system to be built. It affects interfaces, data

structures, behavior, program control flow, the manner in which testing is conducted,

maintainability of the resultant system, and much more.

 Focus on the design of the data:

Data design encompasses the manner in which the data objects are realized within the design.

It helps to simplify the program flow, makes the design and implementation of the software

components easier, and makes overall processing more efficient.

 User interfaces should consider the user first:

The user interface is the main thing of any software. No matter how good its internal

functions are or how well designed its architecture is but if the user interface is poor and end-

users don’t feel ease to handle the software then it leads to the opinion that the software is

bad.

 Components should be loosely coupled:

Coupling of different components into one is done in many ways like via a component

interface, by messaging, or through global data. As the level of coupling increases, error

propagation also increases, and overall maintainability of the software decreases. Therefore,

component coupling should be kept as low as possible.

 Interfaces both user and internal must be designed:

The data flow between components decides the processing efficiency, error flow, and design

simplicity. A well-designed interface makes integration easier and tester can validate the

component functions more easily.

 Component level design should exhibit Functional independence:

It means that functions delivered by component should be cohesive i.e. it should focus on one

and only one function or sub-function.

3.5 Unit End Question

Very Short Questions

Q1. What is Design Engineering?

Q2. Define Software Design?

Q3. What are the objectives of Software Design?

Q4. What are the benefits of problem partitioning?

Q5. Define properties of a modular system?

Q6. Why design process is important?

Q7. What are design principles?

Q8. How to Draw a Component Diagram?

Q9. How to adapt the design process to your needs?

Short Questions

Q1. What are Software Design Principles?

Q2. What are the Advantages and Disadvantages of Modularity?

Q3. Explain Modular Design?

Q4. What are golden rules during the design of the Interface?

Q5. Explain Engineering Design Process Steps?

Long Questions

Q1. Explain Design Process?

Q2. Define Design Quality in length?

Q3. Explain Design Concepts?

Q4. Explain Data Design, Architectural & Interface Design Elements?

Q5. Explain Component level diagram elements & Deployment level deng elements?