Unit 5.

Software Design
5.1. Objectives of design

Objectives of Software Design

The following objectives describe what is software design in software engineering.

• Correctness: A good design should be correct, which means that it should correctly
implement all of the system's features.
• Efficiency: A good software design should consider resource, time, and cost optimization
parameters.
• Understandability: A good design should be easy to grasp, which is why it should be
modular, with all parts organized in layers.
• Completeness: The design should include all components, such as data structures,
modules, and external interfaces, among others.
• Maintainability: A good software design should be flexible when the client issues a
modification request.

5.2. Design framework

A software framework is a structure that you can use to build software. It acts as a
foundation so you don't have to deal with creating unnecessary extra logic from scratch .

Software framework includes:

• Tasks – focus on a small, specific objective.
• Action – set of tasks that produce a major work product.
• Activities – group of related tasks and actions for a major objective.
Framework Activities:

• Communication: Communication with consumers and stakeholders to determine

the system’s objectives and the software’s requirements.
• Planning: Establish engineering work plan, describes technical risk, lists resources
requirements, work produced and defines work schedule.
• Modeling: Architectural models and design to better understand the problem and
for work towards the best solution. Construction: Creating code, testing the
system, fixing bugs, and confirming that all criteria are met.
• Deployment: In this activity, a complete or non-complete product or software is
represented to the customers to evaluate and give feedback.

Umbrella activities: Umbrella Activities are that take place during a software
development process for improved project management and tracking.
1. Software project tracking and control
2. Risk management
3. Software quality assurance
4. Formal technical reviews
5. Software configuration management
6. Work product preparation and production
7. Reusability management

5.3. Software design models

Software design models are conceptual frameworks used by software engineers and designers
to guide the process of creating high-quality, efficient, and maintainable software systems.

1. Object-Oriented Design (OOD):

Object-oriented design revolves around the concept of objects, which are instances of classes
that encapsulate data and behavior. This design model promotes modularity, reusability, and
maintainability.

2. Structured Design:

Structured design focuses on breaking down a system into smaller modules or functions. This
approach promotes modularization and information hiding. The design is represented using
tools like hierarchy charts and data flow diagrams.

3. Model-View-Controller (MVC):

MVC is a design pattern commonly used in web and desktop applications. It separates an
application into three main components: the Model (data and business logic), the View (user
interface), and the Controller (handles user input and manages interactions between the Model
and View).

4. Component-Based Design:

In component-based design, software systems are built by assembling pre-defined, self-

contained components. Each component encapsulates a specific piece of functionality and can
be reused across different projects.

5. Service-Oriented Architecture (SOA):

SOA focuses on organizing software components into services, which are self-contained units
of functionality that can be accessed and reused by other components or applications over a
network. This design approach enhances interoperability and scalability.
5.4. Design process
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: 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.

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.

Detailed Design: 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
• Algorithms and data structures
5.5. Architecture design
The architecture of a system describes its major components, their relationships (structures), and
how they interact with each other. Software architecture and design includes several contributory
factors such as Business strategy, quality attributes, human dynamics, design, and IT
environment.

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.
5.6. Low level design
Low-level design refers to the process of specifying and defining the detailed design of a software
system. This type of design focuses on the implementation details of a system and is concerned with
how the system will be built and how it will function at a detailed level.

Steps involved in the low-level design

1. Understanding requirements: This includes reviewing the requirements document,

talking to stakeholders, and gathering additional information to better understand what
the system should do.

2. Defining the architecture: This involves identifying the various components that make
up the system and defining how they will interact with each other.

3. Designing the components: This includes specifying the data structures and algorithms
to be used, and defining the interfaces between components.

4. Defining protocols: This includes specifying the data formats, message structures, and
communication protocols that will be used.

5. Creating UML diagrams: To help communicate the design, UML (Unified Modeling
Language) diagrams may be created to illustrate the architecture and the interactions
between components.

6. Reviewing the design: Once the design is completed, it must be reviewed to ensure that
it meets the requirements and is technically sound.

7. Refining the design: If necessary, the design can be refined based on feedback received
during the review process. This may involve changing the data structures, algorithms, or
protocols used in the design.

8. Documenting the design: Once the design has been finalized, it is important to
document it in a way that is clear, concise, and easy to understand.
5.7. Software design strategies

• Function- oriented design

In the function-oriented design, the system is designed according to the functionality it offers. The
system is first widely observed and then each of its functions is observed to identify the sub-
functions that it consists of that are responsible for performing that particular functionality.

• Object- oriented design

In the object-oriented design approach to design any software, everything is considered as an

object. Now, every object performs some activities and possess some behavior. This is defined
through classes because all the objects that belong to the same class will exhibit a similar kind of
behavior and will also perform similar functionalities.

• Bottom-up approach:
The design starts with the lowest level components and subsystems. By using these
components, the next immediate higher-level components and subsystems are created or
composed. The process is continued till all the components and subsystems are composed into
a single component, which is considered as the complete system. The amount of abstraction
grows high as the design moves to more high levels.

• Top-down approach: Each system is divided into several subsystems and components. Each
of the subsystems is further divided into a set of subsystems and components. This process of
division facilitates forming a system hierarchy structure. The complete software system is
considered a single entity and in relation to the characteristics, the system is split into sub-
systems and components. The same is done with each of the sub-systems.
5.8. Function oriented design Vs Object oriented design