Software

Design
Software Engineering and Modelling
TABLE OF CONTENTS
0 Software Design 0 Structured Design
Process 2 Methodologies
1
0 Modules Coupling 0 Case Study
3 / Cohesion 4
 0
1
Software
Design
Process
Software design process refers to
the
systematic approach used to
develop
software applications by following a
set
of guidelines, principles, and
practices.
Design Process Stages
1
Requirements
2
System 3
Design
Gathering
Defining the problem and
Analysis
Designing the system
Specification
Creating detailed specifications
gathering requirements by architecture and identifying that outline how each
identifying user needs. the components used to component of the system is
implement the system. implemented.

4
Implementati 5
Integration
6
Maintenance
on
coding the software system
And Testing
Integrating the different developers must continue to
according to the design components of the software maintain and update it to
specifications and making it system and testing them to ensure that it continues to
work. ensure that they function meet the needs of its users.
correctly together. This includes fixing bugs,
updating components
Software Design
Objectives
● Functionality: The software system should
provide the functionality required to meet the
needs of its users.
● Usability: The software system should be easy to
use, with a user interface that is intuitive and
user-friendly.
● Performance: The software system should
perform well, with fast response times and
efficient resource utilization.
● Reliability: The software system should be
reliable and stable, with minimal downtime and
errors.
● Maintainability: The software system should be
designed in a way that makes it easy to maintain,
update, and modify over time.
● Scalability: The software system should be
designed to scale up or down as needed
● Security: Designed with appropriate security
measures to protect user data and prevent
unauthorized access.
● Compliance: Comply with relevant industry
standards and regulations, such as data privacy
and security regulations.
 0
Structured
2
Design
Methodolo
gies
Structured design methodologies are
systematic approaches to software
design that rely on a set of
guidelines
and practices to create well-
structured,
reliable, and maintainable software
systems.
Some common structured design methodologies
in software engineering include:
● Structured Systems Analysis
and Design Method (SSADM):
SSADM is a structured approach to
system analysis and design that
emphasizes the use of data flow
diagrams (DFDs) and other
graphical tools to model the
system's processes and data flows.

● Object-Oriented Analysis and

Design (OOAD): OOAD is a
structured approach to software
design that emphasizes the use of
object-oriented principles and
practices. It involves the
identification of objects and their
relationships, the definition of
Some common structured design methodologies
in software engineering include:
● Jackson Structured
Programming (JSP): JSP is a
structured approach to software
design that emphasizes the use of
top-down design and stepwise
refinement. It involves breaking
down the system into smaller and
more manageable components,
and then refining these
components until they can be
implemented as code.

● Yourdon Structured Method

(YSM): YSM is a structured
approach to software design that
emphasizes the use of data flow
diagrams, entity relationship
diagrams (ERDs), and other
 0
Module
3
Coupling
And
Cohesion
Coupling refers to the degree to
which
different modules or components of
a
software system are interconnected
or
dependent on each other. Module
Cohesion refers to the degree to
which
the elements within a module or
component of a software system are
related to each other and focused
on a
 COUPLING
TYPES
o Content coupling: Two or more modules are tightly coupled
if they share the same data or code directly. This means that
changes to one module can affect the behavior of another
module.
o Common coupling: Two or more modules are coupled if they
share a global data or resource. This can make it difficult to
test and debug software.
o External coupling: Two or more modules are coupled if they
depend on a common external interface or communication
protocol.
o Control coupling: Two or more modules are coupled if one
module controls the behavior of another module. This type
of coupling can make software difficult to modify and can
lead to spaghetti code.
o Stamp coupling: Two or more modules are coupled if they
share a common data structure. This type of coupling can
make software difficult to modify and maintain.
o Data coupling: Two or more modules are coupled if they
communicate through parameters or arguments
o No direct coupling: Two or more modules are decoupled if
they do not share any direct dependencies.
 COHESION
TYPES
o Functional cohesion: In this type of cohesion, the
elements within the module are related to each other
and focused on performing a single function or task.
o Sequential cohesion: In this type of cohesion, the
elements within the module are related to each other
and focused on performing a series of sequential tasks
or operations.
o Communicational cohesion: In this type of cohesion, the
elements within the module are related to each other
and focused on performing operations on the same data
or communicating with the same external entity.
o Procedural cohesion: In this type of cohesion, the
elements within the module are related to each other
and focused on performing a specific sequence of
operations or steps.
o Temporal cohesion: In this type of cohesion, the
elements within the module are related to each other
and focused on performing operations that are related
to a specific time or event.
Case study:
Designing a task management system

A software development company has been contracted to design a task management system for a small
business. The system should allow users to create and assign tasks, track progress, and receive
notifications when tasks are due. The software development company has a team of designers and
developers who will work together to design and develop the system.

Software Design Process:

• Requirement gathering: The software development team meets with the client to gather requirements for
the task management system. They discuss the business processes and goals, user needs, and
technical requirements.
• Analysis and design: The development team analyzes the requirements and creates a design document
outlining the system architecture, data model, user interface design, and functionality.
• Implementation: The developers write code to implement the design. They use a modular approach,
dividing the system into separate modules for tasks, users, notifications, and reporting.
• Testing and quality assurance: The development team tests the system to ensure it meets the
requirements and is free of bugs. They use automated testing tools and manual testing to identify and fix
any issues.
Coupling and Cohesion:

 To ensure that the system is modular and maintainable, the development team pays close
attention to coupling and cohesion. They use the following techniques:
 Module cohesion: The development team designs each module to be highly cohesive, meaning
that each module has a single responsibility and a clear interface. For example, the task module
is responsible for managing tasks and has functions for creating, editing, and deleting tasks.
 Low coupling: The development team designs each module to have low coupling, meaning that
modules are independent and have minimal dependencies on other modules. For example, the
task module does not depend on the user module, but instead receives user data through
parameters.
 Loose coupling: The development team uses message passing to communicate between
modules, which allows for loose coupling. For example, the notification module sends a message
to the user module to notify the user of a new task.

Conclusion:
By following a structured software design process and paying attention to coupling and cohesion, the
development team is able to create a modular and maintainable task management system that
meets the client's requirements.
THANK YOU
Team Members-