SOFTWARE DESIGN

Software Design Notes

1. Design Concepts
• Abstraction:
o Abstraction is the process of hiding the
complex implementation details and
showing only the essential features of an
object or a system.
o It allows developers to focus on what an
object does instead of how it does it,
making the system easier to understand
and manage.
o Examples: Abstract data types (e.g.,
stacks, queues), interfaces in OOP.
• Modularity:
o Modularity is the division of a software
system into separate components or
modules that can be developed, tested,
and maintained independently.
 o It promotes separation of concerns,
reusability, and easier maintenance.
o Each module should have a well-defined
interface and should perform a specific
function within the system.
o Examples: Breaking down a system into
layers like the presentation layer,
business logic layer, and data access layer.
• Encapsulation:
o Encapsulation is the bundling of data and
methods that operate on the data within
a single unit, typically a class in OOP.
o It restricts access to some of an object’s
components, which can prevent the
accidental modification of data.
o Encapsulation ensures that an object's
internal state is protected and can only
be modified by controlled methods.
o Examples: Private and protected access
modifiers in classes.
2. Architectural Design
• High-Level Structuring:
o Architectural design is about defining the
overall structure of a software system,
including its components, their
relationships, and how they interact with
each other.
o It provides a blueprint for the system and
guides the detailed design and
implementation.
• Architectural Styles and Patterns:
o Architectural Styles:
▪ Layered Architecture: Divides the
system into layers, each with specific
responsibilities (e.g., presentation,
business logic, data access).
▪ Client-Server Architecture: Involves
two parties: a client (requester) and a
server (provider of
services/resources).
 ▪ Microservices Architecture:
Composes the system as a collection
of loosely coupled services that can
be developed, deployed, and scaled
independently.
▪ Event-Driven Architecture: Promotes
the system to react to events, often
used in real-time or distributed
systems.
o Architectural Patterns:
▪ Model-View-Controller (MVC):
Separates concerns by dividing the
application into the Model (data),
View (UI), and Controller (logic).
▪ Repository Pattern: Provides a
consistent way to access data from
different data sources, typically used
in data access layers.
▪ Service-Oriented Architecture (SOA):
Structures the system as a collection
 of services that can communicate
over a network.
3. Detailed Design
• UML Diagrams:
o Class Diagrams:
▪ Illustrate the static structure of a
system by showing its classes,
attributes, methods, and
relationships between objects.
▪ They help in understanding and
designing the object-oriented
structure of the system.
o Sequence Diagrams:
▪ Represent the flow of messages
between objects over time, showing
how objects interact in a particular
sequence to carry out a function.
▪ Useful for modeling the dynamic
behavior of a system.
o Activity Diagrams:
 ▪ Visualize the flow of activities in a
system, highlighting the control flow
from one activity to another.
▪ They are often used to model
business processes and workflows.
o State Diagrams:
▪ Depict the states an object can be in
and how it transitions from one state
to another due to events.
▪ Useful for modeling the behavior of
objects over their lifetime.
These concepts and tools help ensure that
software systems are well-structured,
maintainable, and scalable, aligning with
best practices in software design.